Loki: Module Index

  • Main Page
  • Modules
  • Namespaces
  • Classes
  • Files

Loki Modules

Here is a list of all modules:
  • Factories
    • Abstract Factory
    • Cached Factory
      • Encapsulation policies
      • Creation policies
      • Eviction policies
      • Statistic policies
    • Factory
      • Factory Error Policies
    • Clone Factory
  • Function objects
  • Pimpl
  • Register
  • Exception-safe code
  • Singleton
    • Creation policies
    • Lifetime policies
      • LongevityLifetime
  • Small objects
    • Internals
  • Smart pointers
    • Ownership policies
    • Storage policies
    • Conversion policies
    • Checking policies
    • StrongPtr Ownership policies
    • Delete policies
    • Reset policies
  • Threading
  • Visitor
Generated on Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


Loki: Factories

  • Classes
  • Files

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Abstract Factory

Abstract Factory
[Factories]

Collaboration diagram for Abstract Factory:

Implements an abstract object factory. More...

Classes

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

Detailed Description

Implements an abstract object factory.

Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Cached Factory

Cached Factory
[Factories]

Collaboration diagram for Cached Factory:

CachedFactory provides an extension of a 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.

Classes

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

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Encapsulation policies

Encapsulation policies
[Cached Factory]

Collaboration diagram for Encapsulation policies:

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

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Creation policies

Creation policies
[Cached Factory]

Collaboration diagram for Creation policies:

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

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Eviction policies

Eviction policies
[Cached Factory]

Collaboration diagram for Eviction policies:

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

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Statistic policies

Statistic policies
[Cached Factory]

Collaboration diagram for Statistic policies:

Gathers information about the cache. More...

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Factory

Factory
[Factories]

Collaboration diagram for Factory:

Implements a generic object factory. More...

Modules

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

Classes

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

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.

Wikipedia

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Factory Error Policies

Factory Error Policies
[Factory]

Collaboration diagram for Factory Error Policies:

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

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Clone Factory

Clone Factory
[Factories]

Collaboration diagram for Clone Factory:

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

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 Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


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

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

Definition at line 1612 of file Functor.h.

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

Chains two functor calls one after another

Definition at line 1777 of file Functor.h.

Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Pimpl

Pimpl

Classes

class | Loki::ConstPropPtr< T >
class | Loki::Pimpl< T, Pointer >
class | ImplOf
class | PImplOf
Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


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

Definition at line 115 of file Register.h.

Function Documentation

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

Must be specialized be the user

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

Must be specialized be the user

Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Exception-safe code

Exception-safe code

Classes

class | Loki::ScopeGuardImplBase
class | Loki::ScopeGuardImpl0< F >
class | Loki::ScopeGuardImpl1< F, P1 >
class | Loki::ScopeGuardImpl2< F, P1, P2 >
class | Loki::ScopeGuardImpl3< F, P1, P2, P3 >
class | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
class | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
class | Loki::ObjScopeGuardImpl0< Obj, MemFun >
class | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
class | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
class | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >

Typedefs

typedef const ScopeGuardImplBase & | Loki::ScopeGuard

Functions

template<class T>
RefToValue< T > | Loki::ByRef (T &t)

Function Documentation

template<class T>
RefToValue<T> Loki::ByRef ( T & t ) [inline]

RefToValue creator.

Definition at line 61 of file RefToValue.h.

Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Singleton

Singleton

Collaboration diagram for Singleton:

Modules

Creation policies
Lifetime policies

Classes

class | Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >
class | Loki::Singleton< T >
Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:11:06 2007 for Loki by doxygen 1.5.1-p1


Loki: Lifetime policies

Lifetime policies
[Singleton]

Collaboration diagram for Lifetime policies:

Modules

LongevityLifetime

Classes

struct | Loki::DefaultLifetime< T >
struct | Loki::PhoenixSingleton< T >
struct | Loki::DeletableSingleton< T >
struct | Loki::SingletonWithLongevity< T >
struct | Loki::NoDestroy< T >
class | Loki::FollowIntoDeath

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
 Loki::LongevityLifetime::DieAsSmallObjectChild
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
 | ) |  |

Assigns an object a longevity; ensures ordered destructions of objects registered thusly during the exit sequence of the application

Definition at line 148 of file Singleton.h.

References Loki::Private::AtExitFn().

Referenced by Loki::OrderedStatic< L, T, P1(*)() >::createObject(), Loki::OrderedStatic< L, T, Loki::Seq< P1 > >::createObject(), Loki::OrderedStatic< L, T, Loki::NullType >::createObject(), Loki::LongevityLifetime::SingletonFixedLongevity< 0, T >::ScheduleDestruction(), Loki::SingletonWithLongevity< T >::ScheduleDestruction(), and Loki::Private::OrderedStaticBase< T >::SetLongevity().

Here is the call graph for this function:

Generated on Sat Jul 7 15:11:06 2007 for Loki by doxygen 1.5.1-p1


Loki: LongevityLifetime

LongevityLifetime
[Lifetime policies]

Collaboration diagram for LongevityLifetime:

Namespaces

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

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...
Generated on Sat Jul 7 15:11:06 2007 for Loki by doxygen 1.5.1-p1


Loki: Small objects

Small objects

Collaboration diagram for Small objects:

Modules

Internals

Classes

struct | Loki::LongevityLifetime::DieAsSmallObjectParent< T >
struct | Loki::LongevityLifetime::DieAsSmallObjectChild< T >
class | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
class | Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
class | Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
Generated on Sat Jul 7 15:11:06 2007 for Loki by doxygen 1.5.1-p1


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.

Definition at line 1019 of file SmallObj.cpp.

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.

Definition at line 1040 of file SmallObj.cpp.

Referenced by Loki::SmallObjAllocator::Deallocate().

std::size_t Loki::GetOffset | ( | std::size_t | numBytes,
 |  | std::size_t | alignment |
 | ) |  |  | [inline]

Calculates index into array where a FixedAllocator of numBytes is located.

Definition at line 1004 of file SmallObj.cpp.

Referenced by Loki::SmallObjAllocator::Allocate(), Loki::SmallObjAllocator::Deallocate(), Loki::SmallObjAllocator::IsCorrupt(), Loki::SmallObjAllocator::SmallObjAllocator(), and Loki::SmallObjAllocator::TrimExcessMemory().

Generated on Sat Jul 7 15:11:06 2007 for Loki by doxygen 1.5.1-p1


Loki: Smart pointers

Smart pointers

Collaboration diagram for Smart pointers:

Namespaces

namespace | std

Modules

Ownership policies
Storage policies
Conversion policies
Checking policies
StrongPtr Ownership policies
Delete policies
Reset policies

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 >

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> (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)

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

Definition at line 1478 of file StrongPtr.h.

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

Definition at line 1458 of file StrongPtr.h.

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

Definition at line 1574 of file SmartPtr.h.

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

Definition at line 1555 of file SmartPtr.h.

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

Definition at line 1518 of file StrongPtr.h.

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::GreaterThan().

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

Definition at line 1498 of file StrongPtr.h.

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

Definition at line 1614 of file SmartPtr.h.

References Loki::GetImpl().

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< | ( | const SmartPtr< T, OP, CP, KP, SP, CNP > & | lhs,
 |  | U * | rhs |
 | ) |  |  | [inline]

operator< for lhs = SmartPtr, rhs = raw pointer

Definition at line 1593 of file SmartPtr.h.

References Loki::GetImpl().

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<= | ( | U * | lhs,
 |  | const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & | rhs |
 | ) |  |  | [inline]

operator<= for lhs = raw pointer, rhs = StrongPtr

Definition at line 1598 of file StrongPtr.h.

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]

operator<= for lhs = StrongPtr, rhs = raw pointer

Definition at line 1578 of file StrongPtr.h.

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::GreaterThan().

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

Definition at line 1692 of file SmartPtr.h.

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

Definition at line 1673 of file SmartPtr.h.

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

Definition at line 1438 of file StrongPtr.h.

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

Definition at line 1418 of file StrongPtr.h.

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

Definition at line 1536 of file SmartPtr.h.

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

Definition at line 1517 of file SmartPtr.h.

References Loki::GetImpl().

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> | ( | U * | lhs,
 |  | const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & | rhs |
 | ) |  |  | [inline]

operator> for lhs = raw pointer, rhs = StrongPtr

Definition at line 1558 of file StrongPtr.h.

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

Definition at line 1654 of file SmartPtr.h.

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

Definition at line 1638 of file StrongPtr.h.

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::GreaterThan().

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

Definition at line 1618 of file StrongPtr.h.

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

Definition at line 1730 of file SmartPtr.h.

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

Definition at line 1711 of file SmartPtr.h.

Generated on Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


Loki: Conversion policies

Conversion policies
[Smart pointers]

Collaboration diagram for Conversion policies:

Classes

struct | Loki::AllowConversion
struct | Loki::DisallowConversion
Generated on Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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:
  • Windows (windows.h)
  • POSIX (pthread.h): No recursive mutex support with pthread. This means: calling Lock() on a Loki::Mutex twice from the same thread before unlocking the mutex deadlocks the system. To avoid this redesign your synchronization. See also: http://sourceforge.net/tracker/index.php?func=detail&aid=1516182&group_id=29557&atid=396647
Generated on Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


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

Definition at line 313 of file Visitor.h.

#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

Definition at line 346 of file Visitor.h.

#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>)

Definition at line 302 of file Visitor.h.

Generated on Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


Loki: AbstractFactory.h Source File

AbstractFactory.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_ABSTRACTFACTORY_INC_
00016 #define LOKI_ABSTRACTFACTORY_INC_
00017
00018 // $Id: AbstractFactory.h 771 2006-10-27 18:05:03Z clitte_bbt $
00019
00020
00021 #include "Typelist.h"
00022 #include "Sequence.h"
00023 #include "TypeManip.h"
00024 #include "HierarchyGenerators.h"
00025
00026 #include <cassert>
00027
00041 namespace Loki
00042 {
00043
00045 // class template AbstractFactoryUnit
00046 // The building block of an Abstract Factory
00048
00049     template <class T>
00050     class AbstractFactoryUnit
00051     {
00052     public:
00053         virtual T* DoCreate(Type2Type<T>) = 0;
00054         virtual ~AbstractFactoryUnit() {}
00055     };
00056
00058 // class template AbstractFactory
00059 // Defines an Abstract Factory interface starting from a typelist
00061
00062     template
00063     <
00064         class TList,
00065         template <class> class Unit = AbstractFactoryUnit
00066     >
00067     class AbstractFactory : public GenScatterHierarchy<TList, Unit>
00068     {
00069     public:
00070         typedef TList ProductList;
00071
00072         template <class T> T* Create()
00073         {
00074             Unit<T>& unit = *this;
00075             return unit.DoCreate(Type2Type<T>());
00076         }
00077     };
00078
00080 // class template OpNewFactoryUnit
00081 // Creates an object by invoking the new operator
00083
00084     template <class ConcreteProduct, class Base>
00085     class OpNewFactoryUnit : public Base
00086     {
00087         typedef typename Base::ProductList BaseProductList;
00088
00089     protected:
00090         typedef typename BaseProductList::Tail ProductList;
00091
00092     public:
00093         typedef typename BaseProductList::Head AbstractProduct;
00094         ConcreteProduct* DoCreate(Type2Type<AbstractProduct>)
00095         {
00096             return new ConcreteProduct;
00097         }
00098     };
00099
00101 // class template PrototypeFactoryUnit
00102 // Creates an object by cloning a prototype
00103 // There is a difference between the implementation herein and the one described
00104 //     in the book: GetPrototype and SetPrototype use the helper friend
00105 //     functions DoGetPrototype and DoSetPrototype. The friend functions avoid
00106 //     name hiding issues. Plus, GetPrototype takes a reference to pointer
00107 //     instead of returning the pointer by value.
00109
00110     template <class ConcreteProduct, class Base>
00111     class PrototypeFactoryUnit : public Base
00112     {
00113         typedef typename Base::ProductList BaseProductList;
00114
00115     protected:
00116         typedef typename BaseProductList::Tail ProductList;
00117
00118     public:
00119         typedef typename BaseProductList::Head AbstractProduct;
00120
00121         PrototypeFactoryUnit(AbstractProduct* p = 0)
00122             : pPrototype_(p)
00123         {}
00124
00125         template <class CP, class Base1>
00126         friend void DoGetPrototype(const PrototypeFactoryUnit<CP, Base1>& me,
00127                                    typename Base1::ProductList::Head*& pPrototype);
00128
00129         template <class CP, class Base1>
00130         friend void DoSetPrototype(PrototypeFactoryUnit<CP, Base1>& me,
00131                                    typename Base1::ProductList::Head* pObj);
00132
00133         template <class U>
00134         void GetPrototype(U*& p)
00135         { return DoGetPrototype(*this, p); }
00136
00137         template <class U>
00138         void SetPrototype(U* pObj)
00139         { DoSetPrototype(*this, pObj); }
00140
00141         AbstractProduct* DoCreate(Type2Type<AbstractProduct>)
00142         {
00143             assert(pPrototype_);
00144             return pPrototype_->Clone();
00145         }
00146
00147     private:
00148         AbstractProduct* pPrototype_;
00149     };
00150
00151     template <class CP, class Base>
00152     inline void DoGetPrototype(const PrototypeFactoryUnit<CP, Base>& me,
00153                                typename Base::ProductList::Head*& pPrototype)
00154     { pPrototype = me.pPrototype_; }
00155
00156     template <class CP, class Base>
00157     inline void DoSetPrototype(PrototypeFactoryUnit<CP, Base>& me,
00158                                typename Base::ProductList::Head* pObj)
00159     { me.pPrototype_ = pObj; }
00160
00162 // class template ConcreteFactory
00163 // Implements an AbstractFactory interface
00165
00166     template
00167     <
00168         class AbstractFact,
00169         template <class, class> class Creator = OpNewFactoryUnit,
00170         class TList = typename AbstractFact::ProductList
00171     >
00172     class ConcreteFactory
00173         : public GenLinearHierarchy<
00174             typename TL::Reverse<TList>::Result, Creator, AbstractFact>
00175     {
00176     public:
00177         typedef typename AbstractFact::ProductList ProductList;
00178         typedef TList ConcreteProductList;
00179     };
00180
00181 } // namespace Loki
00182
00183
00184 #endif // end file guardian
00185
Generated on Sat Jul 7 15:10:59 2007 for Loki by doxygen 1.5.1-p1


Loki: AssocVector.h Source File

AssocVector.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_ASSOCVECTOR_INC_
00016 #define LOKI_ASSOCVECTOR_INC_
00017
00018 // $Id: AssocVector.h 765 2006-10-18 13:55:32Z syntheticpp $
00019
00020
00021 #include <algorithm>
00022 #include <functional>
00023 #include <vector>
00024 #include <utility>
00025
00026 namespace Loki
00027 {
00029 // class template AssocVectorCompare
00030 // Used by AssocVector
00032
00033     namespace Private
00034     {
00035         template <class Value, class C>
00036         class AssocVectorCompare : public C
00037         {
00038             typedef std::pair<typename C::first_argument_type, Value>
00039                 Data;
00040             typedef typename C::first_argument_type first_argument_type;
00041
00042         public:
00043             AssocVectorCompare()
00044             {}
00045
00046             AssocVectorCompare(const C& src) : C(src)
00047             {}
00048
00049             bool operator()(const first_argument_type& lhs,
00050                 const first_argument_type& rhs) const
00051             { return C::operator()(lhs, rhs); }
00052
00053             bool operator()(const Data& lhs, const Data& rhs) const
00054             { return operator()(lhs.first, rhs.first); }
00055
00056             bool operator()(const Data& lhs,
00057                 const first_argument_type& rhs) const
00058             { return operator()(lhs.first, rhs); }
00059
00060             bool operator()(const first_argument_type& lhs,
00061                 const Data& rhs) const
00062             { return operator()(lhs, rhs.first); }
00063         };
00064     }
00065
00067 // class template AssocVector
00068 // An associative vector built as a syntactic drop-in replacement for std::map
00069 // BEWARE: AssocVector doesn't respect all map's guarantees, the most important
00070 //     being:
00071 // * iterators are invalidated by insert and erase operations
00072 // * the complexity of insert/erase is O(N) not O(log N)
00073 // * value_type is std::pair<K, V> not std::pair<const K, V>
00074 // * iterators are random
00076
00077
00078     template
00079     <
00080         class K,
00081         class V,
00082         class C = std::less<K>,
00083         class A = std::allocator< std::pair<K, V> >
00084     >
00085     class AssocVector
00086         : private std::vector< std::pair<K, V>, A >
00087         , private Private::AssocVectorCompare<V, C>
00088     {
00089         typedef std::vector<std::pair<K, V>, A> Base;
00090         typedef Private::AssocVectorCompare<V, C> MyCompare;
00091
00092     public:
00093         typedef K key_type;
00094         typedef V mapped_type;
00095         typedef typename Base::value_type value_type;
00096
00097         typedef C key_compare;
00098         typedef A allocator_type;
00099         typedef typename A::reference reference;
00100         typedef typename A::const_reference const_reference;
00101         typedef typename Base::iterator iterator;
00102         typedef typename Base::const_iterator const_iterator;
00103         typedef typename Base::size_type size_type;
00104         typedef typename Base::difference_type difference_type;
00105         typedef typename A::pointer pointer;
00106         typedef typename A::const_pointer const_pointer;
00107         typedef typename Base::reverse_iterator reverse_iterator;
00108         typedef typename Base::const_reverse_iterator const_reverse_iterator;
00109
00110         class value_compare
00111             : public std::binary_function<value_type, value_type, bool>
00112             , private key_compare
00113         {
00114             friend class AssocVector;
00115
00116         protected:
00117             value_compare(key_compare pred) : key_compare(pred)
00118             {}
00119
00120         public:
00121             bool operator()(const value_type& lhs, const value_type& rhs) const
00122             { return key_compare::operator()(lhs.first, rhs.first); }
00123         };
00124
00125         // 23.3.1.1 construct/copy/destroy
00126
00127         explicit AssocVector(const key_compare& comp = key_compare(),
00128             const A& alloc = A())
00129         : Base(alloc), MyCompare(comp)
00130         {}
00131
00132         template <class InputIterator>
00133         AssocVector(InputIterator first, InputIterator last,
00134             const key_compare& comp = key_compare(),
00135             const A& alloc = A())
00136         : Base(first, last, alloc), MyCompare(comp)
00137         {
00138             MyCompare& me = *this;
00139             std::sort(begin(), end(), me);
00140         }
00141
00142         AssocVector& operator=(const AssocVector& rhs)
00143         {
00144             AssocVector(rhs).swap(*this);
00145             return *this;
00146         }
00147
00148         // iterators:
00149         // The following are here because MWCW gets 'using' wrong
00150         iterator begin() { return Base::begin(); }
00151         const_iterator begin() const { return Base::begin(); }
00152         iterator end() { return Base::end(); }
00153         const_iterator end() const { return Base::end(); }
00154         reverse_iterator rbegin() { return Base::rbegin(); }
00155         const_reverse_iterator rbegin() const { return Base::rbegin(); }
00156         reverse_iterator rend() { return Base::rend(); }
00157         const_reverse_iterator rend() const { return Base::rend(); }
00158
00159         // capacity:
00160         bool empty() const { return Base::empty(); }
00161         size_type size() const { return Base::size(); }
00162         size_type max_size() { return Base::max_size(); }
00163
00164         // 23.3.1.2 element access:
00165         mapped_type& operator[](const key_type& key)
00166         { return insert(value_type(key, mapped_type())).first->second; }
00167
00168         // modifiers:
00169         std::pair<iterator, bool> insert(const value_type& val)
00170         {
00171             bool found(true);
00172             iterator i(lower_bound(val.first));
00173
00174             if (i == end() || this->operator()(val.first, i->first))
00175             {
00176                 i = Base::insert(i, val);
00177                 found = false;
00178             }
00179             return std::make_pair(i, !found);
00180         }
00181         //Section [23.1.2], Table 69
00182         //http://developer.apple.com/documentation/DeveloperTools/gcc-3.3/libstdc++/23_containers/howto.html#4
00183         iterator insert(iterator pos, const value_type& val)
00184         {
00185             if( (pos == begin() || this->operator()(*(pos-1),val)) &&
00186                 (pos == end()    || this->operator()(val, *pos)) )
00187             {
00188                 return Base::insert(pos, val);
00189             }
00190             return insert(val).first;
00191         }
00192
00193         template <class InputIterator>
00194         void insert(InputIterator first, InputIterator last)
00195         { for (; first != last; ++first) insert(*first); }
00196
00197         void erase(iterator pos)
00198         { Base::erase(pos); }
00199
00200         size_type erase(const key_type& k)
00201         {
00202             iterator i(find(k));
00203             if (i == end()) return 0;
00204             erase(i);
00205             return 1;
00206         }
00207
00208         void erase(iterator first, iterator last)
00209         { Base::erase(first, last); }
00210
00211         void swap(AssocVector& other)
00212         {
00213             Base::swap(other);
00214             MyCompare& me = *this;
00215             MyCompare& rhs = other;
00216             std::swap(me, rhs);
00217         }
00218
00219         void clear()
00220         { Base::clear(); }
00221
00222         // observers:
00223         key_compare key_comp() const
00224         { return *this; }
00225
00226         value_compare value_comp() const
00227         {
00228             const key_compare& comp = *this;
00229             return value_compare(comp);
00230         }
00231
00232         // 23.3.1.3 map operations:
00233         iterator find(const key_type& k)
00234         {
00235             iterator i(lower_bound(k));
00236             if (i != end() && this->operator()(k, i->first))
00237             {
00238                 i = end();
00239             }
00240             return i;
00241         }
00242
00243         const_iterator find(const key_type& k) const
00244         {
00245             const_iterator i(lower_bound(k));
00246             if (i != end() && this->operator()(k, i->first))
00247             {
00248                 i = end();
00249             }
00250             return i;
00251         }
00252
00253         size_type count(const key_type& k) const
00254         { return find(k) != end(); }
00255
00256         iterator lower_bound(const key_type& k)
00257         {
00258             MyCompare& me = *this;
00259             return std::lower_bound(begin(), end(), k, me);
00260         }
00261
00262         const_iterator lower_bound(const key_type& k) const
00263         {
00264             const MyCompare& me = *this;
00265             return std::lower_bound(begin(), end(), k, me);
00266         }
00267
00268         iterator upper_bound(const key_type& k)
00269         {
00270             MyCompare& me = *this;
00271             return std::upper_bound(begin(), end(), k, me);
00272         }
00273
00274         const_iterator upper_bound(const key_type& k) const
00275         {
00276             const MyCompare& me = *this;
00277             return std::upper_bound(begin(), end(), k, me);
00278         }
00279
00280         std::pair<iterator, iterator> equal_range(const key_type& k)
00281         {
00282             MyCompare& me = *this;
00283             return std::equal_range(begin(), end(), k, me);
00284         }
00285
00286         std::pair<const_iterator, const_iterator> equal_range(
00287             const key_type& k) const
00288         {
00289             const MyCompare& me = *this;
00290             return std::equal_range(begin(), end(), k, me);
00291         }
00292
00293         template <class K1, class V1, class C1, class A1>
00294         friend bool operator==(const AssocVector<K1, V1, C1, A1>& lhs,
00295                         const AssocVector<K1, V1, C1, A1>& rhs);
00296
00297         bool operator<(const AssocVector& rhs) const
00298         {
00299             const Base& me = *this;
00300             const Base& yo = rhs;
00301             return me < yo;
00302         }
00303
00304         template <class K1, class V1, class C1, class A1>
00305         friend bool operator!=(const AssocVector<K1, V1, C1, A1>& lhs,
00306                                const AssocVector<K1, V1, C1, A1>& rhs);
00307
00308         template <class K1, class V1, class C1, class A1>
00309         friend bool operator>(const AssocVector<K1, V1, C1, A1>& lhs,
00310                               const AssocVector<K1, V1, C1, A1>& rhs);
00311
00312         template <class K1, class V1, class C1, class A1>
00313         friend bool operator>=(const AssocVector<K1, V1, C1, A1>& lhs,
00314                                const AssocVector<K1, V1, C1, A1>& rhs);
00315
00316         template <class K1, class V1, class C1, class A1>
00317         friend bool operator<=(const AssocVector<K1, V1, C1, A1>& lhs,
00318                                const AssocVector<K1, V1, C1, A1>& rhs);
00319     };
00320
00321     template <class K, class V, class C, class A>
00322     inline bool operator==(const AssocVector<K, V, C, A>& lhs,
00323                            const AssocVector<K, V, C, A>& rhs)
00324     {
00325       const std::vector<std::pair<K, V>, A>& me = lhs;
00326       return me == rhs;
00327     }
00328
00329     template <class K, class V, class C, class A>
00330     inline bool operator!=(const AssocVector<K, V, C, A>& lhs,
00331                            const AssocVector<K, V, C, A>& rhs)
00332     { return !(lhs == rhs); }
00333
00334     template <class K, class V, class C, class A>
00335     inline bool operator>(const AssocVector<K, V, C, A>& lhs,
00336                           const AssocVector<K, V, C, A>& rhs)
00337     { return rhs < lhs; }
00338
00339     template <class K, class V, class C, class A>
00340     inline bool operator>=(const AssocVector<K, V, C, A>& lhs,
00341                            const AssocVector<K, V, C, A>& rhs)
00342     { return !(lhs < rhs); }
00343
00344     template <class K, class V, class C, class A>
00345     inline bool operator<=(const AssocVector<K, V, C, A>& lhs,
00346                            const AssocVector<K, V, C, A>& rhs)
00347     { return !(rhs < lhs); }
00348
00349
00350     // specialized algorithms:
00351     template <class K, class V, class C, class A>
00352     void swap(AssocVector<K, V, C, A>& lhs, AssocVector<K, V, C, A>& rhs)
00353     { lhs.swap(rhs); }
00354
00355 } // namespace Loki
00356
00357 #endif // end file guardian
00358
Generated on Sat Jul 7 15:10:59 2007 for Loki by doxygen 1.5.1-p1


Loki: CachedFactory.h Source File

CachedFactory.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 by Guillaume Chatelet
00004 //
00005 // Code covered by the MIT License
00006 //
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 // purpose is hereby granted without fee, provided that the above copyright
00009 // notice appear in all copies and that both that copyright notice and this
00010 // permission notice appear in supporting documentation.
00011 //
00012 // The authors make no representations about the suitability of this software
00013 // for any purpose. It is provided "as is" without express or implied warranty.
00014 //
00015 // This code DOES NOT accompany the book:
00016 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00017 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00018 //
00020 #ifndef LOKI_CACHEDFACTORY_INC_
00021 #define LOKI_CACHEDFACTORY_INC_
00022
00023 // $Id: CachedFactory.h 810 2007-02-25 14:36:28Z syntheticpp $
00024
00025 #include <functional>
00026 #include <algorithm>
00027 #include <iostream>
00028 #include <vector>
00029 #include <iterator>
00030 #include <map>
00031 #include <cassert>
00032 #include <loki/Key.h>
00033
00034 #ifdef DO_EXTRA_LOKI_TESTS
00035      #define D( x ) x
00036 #else
00037      #define D( x ) ;
00038 #endif
00039
00040 #ifdef _MSC_VER
00041 #include <time.h>
00042 #endif
00043
00056 namespace Loki
00057 {
00071      template<class AbstractProduct>
00072      class SimplePointer
00073      {
00074      protected:
00075            typedef AbstractProduct* ProductReturn;
00076            ProductReturn encapsulate(AbstractProduct* pProduct)
00077            {
00078                 return pProduct;
00079            }
00080
00081            AbstractProduct* release(ProductReturn &pProduct)
00082            {
00083                 AbstractProduct* pPointer(pProduct);
00084                 pProduct=NULL;
00085                 return pPointer;
00086            }
00087            const char* name(){return "pointer";}
00088      };
00089
00108      class NeverCreate
00109      {
00110      protected:
00111             struct Exception : public std::exception
00112             {
00113                 const char* what() const throw() { return "NeverFetch Policy : No Fetching allowed"; }
00114             };
00115
00116             bool canCreate()
00117             {
00118                 throw Exception();
00119             }
00120
00121             void onCreate(){}
00122             void onDestroy(){}
00123             const char* name(){return "never";}
00124      };
00125
00133      class AlwaysCreate
00134      {
00135      protected:
00136             bool canCreate()
00137             {
00138                 return true;
00139             }
00140
00141             void onCreate(){}
00142             void onDestroy(){}
00143             const char* name(){return "always";}
00144      };
00145
00146
00158      // !! CAUTION !!
00159      // The std::clock() function is not quite precise
00160      // under linux this policy might not work.
00161      // TODO : get a better implementation (platform dependant)
00162      class RateLimitedCreation
00163      {
00164      private:
00165             typedef std::vector< clock_t > Vector;
00166             Vector m_vTimes;
00167             unsigned maxCreation;
00168             clock_t timeValidity;
00169             clock_t lastUpdate;
00170
00171             void cleanVector()
00172             {
00173                using namespace std;
00174                     clock_t currentTime = clock();
00175                 D( cout << "currentTime = " << currentTime<< endl; )
00176                 D( cout << "currentTime - lastUpdate = " << currentTime - lastUpdate<< endl; )
00177                 if(currentTime - lastUpdate > timeValidity)
00178                 {
00179                     m_vTimes.clear();
00180                     D( cout << " is less than time validity " << timeValidity; )
00181                     D( cout << " so clearing vector" << endl; )
00182                 }
00183                 else
00184                 {
00185                     D( cout << "Cleaning time less than " << currentTime - timeValidity << endl; )
00186                     D( displayVector(); )
00187                     Vector::iterator newEnd = remove_if(m_vTimes.begin(), m_vTimes.end(), bind2nd(less<clock_t>(), currentTime - timeValidity));
00188                     // this rearrangement might be costly, consider optimization
00189                     // by calling cleanVector in less used onCreate function
00190                     // ... although it may not be correct
00191                     m_vTimes.erase(newEnd, m_vTimes.end());
00192                     D( displayVector(); )
00193                 }
00194                 lastUpdate = currentTime;
00195             }
00196 #ifdef DO_EXTRA_LOKI_TESTS
00197             void displayVector()
00198             {
00199                 std::cout << "Vector : ";
00200                 copy(m_vTimes.begin(), m_vTimes.end(), std::ostream_iterator<clock_t>(std::cout, " "));
00201                 std::cout << std::endl;
00202             }
00203 #endif
00204      protected:
00205             RateLimitedCreation() : maxCreation(10), timeValidity(CLOCKS_PER_SEC), lastUpdate(clock())
00206             {}
00207
00208             struct Exception : public std::exception
00209             {
00210                 const char* what() const throw() { return "RateLimitedCreation Policy : Exceeded the authorized creation rate"; }
00211             };
00212
00213             bool canCreate()
00214             {
00215                 cleanVector();
00216                 if(m_vTimes.size()>maxCreation)
00217                     throw Exception();
00218                 else
00219                     return true;
00220             }
00221
00222             void onCreate()
00223             {
00224                     m_vTimes.push_back(clock());
00225             }
00226
00227             void onDestroy()
00228             {
00229             }
00230             const char* name(){return "rate limited";}
00231      public:
00232             // set the creation rate
00233             // No more than maxCreation within byTime milliseconds
00234             void setRate(unsigned maxCreation, unsigned byTime)
00235             {
00236                 assert(byTime>0);
00237                 this->maxCreation = maxCreation;
00238                 this->timeValidity = static_cast<clock_t>(byTime * CLOCKS_PER_SEC / 1000);
00239                 D( std::cout << "Setting no more than "<< maxCreation <<" creation within " << this->timeValidity <<" ms"<< std::endl; )
00240             }
00241      };
00242
00253      class AmountLimitedCreation
00254      {
00255      private:
00256             unsigned maxCreation;
00257             unsigned created;
00258
00259      protected:
00260             AmountLimitedCreation() : maxCreation(10), created(0)
00261             {}
00262
00263             bool canCreate()
00264             {
00265                return !(created>=maxCreation);
00266             }
00267
00268             void onCreate()
00269             {
00270                 ++created;
00271             }
00272
00273             void onDestroy()
00274             {
00275                 --created;
00276             }
00277             const char* name(){return "amount limited";}
00278      public:
00279             // set the creation max amount
00280             void setMaxCreation(unsigned maxCreation)
00281             {
00282                 assert(maxCreation>0);
00283                 this->maxCreation = maxCreation;
00284                 D( std::cout << "Setting no more than " << maxCreation <<" creation" << std::endl; )
00285             }
00286      };
00287
00295     class EvictionException : public std::exception
00296     {
00297     public:
00298         const char* what() const throw() { return "Eviction Policy : trying to make room but no objects are available"; }
00299     };
00300
00301     // The following class is intented to provide helpers to sort
00302     // the container that will hold an eviction score
00303     template
00304     <
00305      typename ST, // Score type
00306      typename DT // Data type
00307     >
00308     class EvictionHelper
00309     {
00310     protected:
00311         typedef typename std::map< DT, ST >            HitMap;
00312         typedef typename HitMap::iterator              HitMapItr;
00313     private:
00314         typedef std::pair< ST, DT >                         SwappedPair;
00315         typedef std::multimap< ST, DT >                SwappedHitMap;
00316      typedef   typename SwappedHitMap::iterator   SwappedHitMapItr;
00317     protected:
00318         HitMap                                              m_mHitCount;
00319
00320      // This function sorts the map according to the score
00321      // and returns the lower bound of the sorted container
00322      DT&  getLowerBound(){
00323           assert(!m_mHitCount.empty());
00324           // inserting the swapped pair into a multimap
00325           SwappedHitMap copyMap;
00326           for(HitMapItr itr = m_mHitCount.begin(); itr != m_mHitCount.end(); ++itr)
00327                copyMap.insert(SwappedPair((*itr).second, (*itr).first));
00328           if((*copyMap.rbegin()).first == 0) // the higher score is 0 ...
00329             throw EvictionException(); // there is no key evict
00330           return (*copyMap.begin()).second;
00331      }
00332     };
00333
00346     template
00347     <
00348      typename DT, // Data Type (AbstractProduct*)
00349      typename ST = unsigned // default data type to use as Score Type
00350     >
00351     class EvictLRU : public EvictionHelper< ST , DT >
00352     {
00353     private:
00354      typedef EvictionHelper< ST , DT >  EH;
00355     protected:
00356
00357         virtual ~EvictLRU(){}
00358
00359      // OnStore initialize the counter for the new key
00360      // If the key already exists, the counter is reseted
00361      void onCreate(const DT& key)
00362         {
00363           EH::m_mHitCount[key] = 0;
00364      }
00365
00366      void onFetch(const DT&)
00367         {
00368      }
00369
00370      // onRelease increments the hit counter associated with the object
00371         void onRelease(const DT& key)
00372         {
00373           ++(EH::m_mHitCount[key]);
00374         }
00375
00376      void onDestroy(const DT& key)
00377      {
00378             EH::m_mHitCount.erase(key);
00379      }
00380
00381      // this function is implemented in Cache and redirected
00382      // to the Storage Policy
00383      virtual void remove(DT const key)=0;
00384
00385      // LRU Eviction policy
00386      void evict()
00387      {
00388           remove(EH::getLowerBound());
00389      }
00390         const char* name(){return "LRU";}
00391     };
00392
00404     template
00405     <
00406      typename DT, // Data Type (AbstractProduct*)
00407      typename ST = unsigned // default data type to use as Score Type
00408     >
00409     class EvictAging : public EvictionHelper< ST, DT >
00410     {
00411     private:
00412         EvictAging(const EvictAging&);
00413         EvictAging& operator=(const EvictAging&);
00414      typedef EvictionHelper< ST, DT >                       EH;
00415      typedef typename EH::HitMap                            HitMap;
00416      typedef typename EH::HitMapItr                         HitMapItr;
00417
00418      // update the counter
00419           template<class T> struct updateCounter : public std::unary_function<T, void>
00420           {
00421                updateCounter(const DT& key): key_(key){}
00422                void operator()(T x)
00423                {
00424                     x.second = (x.first == key_ ? (x.second >> 1) | ( 1 << ((sizeof(ST)-1)*8) ) : x.second >> 1);
00425                D( std::cout <<  x.second << std::endl; )
00426                }
00427                const DT &key_;
00428             updateCounter(const updateCounter& rhs) : key_(rhs.key_){}
00429         private:
00430             updateCounter& operator=(const updateCounter& rhs);
00431           };
00432     protected:
00433          EvictAging(){}
00434          virtual ~EvictAging(){}
00435
00436      // OnStore initialize the counter for the new key
00437      // If the key already exists, the counter is reseted
00438      void onCreate(const DT& key){
00439           EH::m_mHitCount[key] = 0;
00440      }
00441
00442      void onFetch(const DT&){}
00443
00444      // onRelease increments the hit counter associated with the object
00445      // Updating every counters by iterating over the map
00446      // If the key is the key of the fetched object :
00447      //  the counter is shifted to the right and it's MSB is set to 1
00448      // else
00449      //  the counter is shifted to the left
00450         void onRelease(const DT& key)
00451         {
00452           std::for_each(EH::m_mHitCount.begin(), EH::m_mHitCount.end(), updateCounter< typename HitMap::value_type >(key));
00453         }
00454
00455         void onDestroy(const DT& key)
00456         {
00457             EH::m_mHitCount.erase(key);
00458         }
00459
00460      // this function is implemented in Cache and redirected
00461      // to the Storage Policy
00462      virtual void remove(DT const key)=0;
00463
00464      // LRU with Aging Eviction policy
00465      void evict()
00466      {
00467           remove(EH::getLowerBound());
00468      }
00469         const char* name(){return "LRU with aging";}
00470     };
00471
00480     template
00481     <
00482      typename DT, // Data Type (AbstractProduct*)
00483      typename ST = void // Score Type not used by this policy
00484     >
00485     class EvictRandom
00486     {
00487     private:
00488      std::vector< DT >   m_vKeys;
00489      typedef typename std::vector< DT >::size_type     size_type;
00490      typedef typename std::vector< DT >::iterator      iterator;
00491
00492     protected:
00493
00494           virtual ~EvictRandom(){};
00495
00496      void onCreate(const DT&){
00497      }
00498
00499      void onFetch(const DT& ){
00500      }
00501
00502      void onRelease(const DT& key){
00503             m_vKeys.push_back(key);
00504      }
00505
00506      void onDestroy(const DT& key){
00507           using namespace std;
00508             m_vKeys.erase(remove_if(m_vKeys.begin(), m_vKeys.end(), bind2nd(equal_to< DT >(), key)), m_vKeys.end());
00509      }
00510
00511      // Implemented in Cache and redirected to the Storage Policy
00512      virtual void remove(DT const key)=0;
00513
00514      // Random Eviction policy
00515      void evict()
00516      {
00517           if(m_vKeys.empty())
00518               throw EvictionException();
00519           size_type random = static_cast<size_type>((m_vKeys.size()*rand())/int(RAND_MAX + 1));
00520           remove(*(m_vKeys.begin()+random));
00521      }
00522         const char* name(){return "random";}
00523     };
00524
00541     class NoStatisticPolicy
00542     {
00543     protected:
00544         void onDebug(){}
00545         void onFetch(){}
00546         void onRelease(){}
00547         void onCreate(){}
00548         void onDestroy(){}
00549         const char* name(){return "no";}
00550     };
00551
00567     class SimpleStatisticPolicy
00568     {
00569     private:
00570         unsigned allocated, created, hit, out, fetched;
00571     protected:
00572         SimpleStatisticPolicy() : allocated(0), created(0), hit(0), out(0), fetched(0)
00573         {
00574         }
00575
00576         void onDebug()
00577         {
00578           using namespace std;
00579             cout << "############################" << endl;
00580             cout << "## About this cache " << this << endl;
00581             cout << "## + Created objects     : " << created << endl;
00582             cout << "## + Fetched objects     : " << fetched << endl;
00583             cout << "## + Destroyed objects   : " << created - allocated << endl;
00584             cout << "## + Cache hit           : " << hit << endl;
00585             cout << "## + Cache miss          : " << fetched - hit << endl;
00586             cout << "## + Currently allocated : " << allocated << endl;
00587             cout << "## + Currently out       : " << out << endl;
00588             cout << "############################" << endl;
00589             if(fetched!=0){
00590                 cout << "## Overall efficiency " << 100*double(hit)/fetched <<"%"<< endl;
00591                 cout << "############################" << endl;
00592             }
00593             cout << endl;
00594         }
00595
00596         void onFetch()
00597         {
00598             ++fetched;
00599             ++out;
00600             ++hit;
00601         }
00602         void onRelease()
00603         {
00604             --out;
00605         }
00606         void onCreate()
00607         {
00608             ++created;
00609             ++allocated;
00610             --hit;
00611         }
00612         void onDestroy()
00613         {
00614             --allocated;
00615         }
00616
00617         const char* name(){return "simple";}
00618     public:
00619         unsigned getCreated(){return created;}
00620         unsigned getFetched(){return fetched;}
00621         unsigned getHit(){return hit;}
00622         unsigned getMissed(){return fetched - hit;}
00623         unsigned getAllocated(){return allocated;}
00624         unsigned getOut(){return out;}
00625         unsigned getDestroyed(){return created-allocated;}
00626     };
00627
00629     // Cache Factory definition
00631     class CacheException : public std::exception
00632     {
00633     public:
00634         const char* what() const throw() { return "Internal Cache Error"; }
00635     };
00636
00648       template
00649      <
00650         class AbstractProduct,
00651         typename IdentifierType,
00652         typename CreatorParmTList = NullType,
00653         template<class> class EncapsulationPolicy = SimplePointer,
00654         class CreationPolicy = AlwaysCreate,
00655         template <typename , typename> class EvictionPolicy = EvictRandom,
00656         class StatisticPolicy = NoStatisticPolicy,
00657         template<typename, class> class FactoryErrorPolicy = DefaultFactoryError,
00658         class ObjVector = std::vector<AbstractProduct*>
00659      >
00660       class CachedFactory :
00661             protected EncapsulationPolicy<AbstractProduct>,
00662             public CreationPolicy, public StatisticPolicy, EvictionPolicy< AbstractProduct * , unsigned >
00663       {
00664      private:
00665         typedef Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy> Factory;
00666         typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl;
00667         typedef Functor< AbstractProduct* , CreatorParmTList > ProductCreator;
00668         typedef EncapsulationPolicy<AbstractProduct> NP;
00669         typedef CreationPolicy  CP;
00670         typedef StatisticPolicy SP;
00671         typedef EvictionPolicy< AbstractProduct* , unsigned > EP;
00672
00673         typedef typename Impl::Parm1 Parm1;
00674         typedef typename Impl::Parm2 Parm2;
00675         typedef typename Impl::Parm3 Parm3;
00676         typedef typename Impl::Parm4 Parm4;
00677         typedef typename Impl::Parm5 Parm5;
00678         typedef typename Impl::Parm6 Parm6;
00679         typedef typename Impl::Parm7 Parm7;
00680         typedef typename Impl::Parm8 Parm8;
00681         typedef typename Impl::Parm9 Parm9;
00682         typedef typename Impl::Parm10 Parm10;
00683         typedef typename Impl::Parm11 Parm11;
00684         typedef typename Impl::Parm12 Parm12;
00685         typedef typename Impl::Parm13 Parm13;
00686         typedef typename Impl::Parm14 Parm14;
00687         typedef typename Impl::Parm15 Parm15;
00688
00689      public:
00690         typedef typename NP::ProductReturn ProductReturn;
00691      private:
00692         typedef Key< Impl, IdentifierType > Key;
00693         typedef std::map< Key, ObjVector >  KeyToObjVectorMap;
00694         typedef std::map< AbstractProduct*, Key >  FetchedObjToKeyMap;
00695
00696         Factory             factory;
00697         KeyToObjVectorMap   fromKeyToObjVector;
00698         FetchedObjToKeyMap  providedObjects;
00699         unsigned            outObjects;
00700
00701         ObjVector& getContainerFromKey(Key key){
00702             return fromKeyToObjVector[key];
00703         }
00704
00705         AbstractProduct* const getPointerToObjectInContainer(ObjVector &entry)
00706         {
00707             if(entry.empty()) // No object available
00708             {   // the object will be created in the calling function.
00709                 // It has to be created in the calling function because of
00710                 // the variable number of parameters for CreateObject(...) method
00711                 return NULL;
00712             }
00713             else
00714             {   // returning the found object
00715                     AbstractProduct* pObject(entry.back());
00716                     assert(pObject!=NULL);
00717                     entry.pop_back();
00718                 return pObject;
00719             }
00720         }
00721
00722         bool shouldCreateObject(AbstractProduct * const pProduct){
00723             if(pProduct!=NULL) // object already exists
00724                 return false;
00725             if(CP::canCreate()==false) // Are we allowed to Create ?
00726                 EP::evict(); // calling Eviction Policy to clean up
00727             return true;
00728         }
00729
00730         void ReleaseObjectFromContainer(ObjVector &entry, AbstractProduct * const object)
00731         {
00732             entry.push_back(object);
00733         }
00734
00735         void onFetch(AbstractProduct * const pProduct)
00736         {
00737             SP::onFetch();
00738             EP::onFetch(pProduct);
00739             ++outObjects;
00740         }
00741
00742         void onRelease(AbstractProduct * const pProduct)
00743         {
00744             SP::onRelease();
00745             EP::onRelease(pProduct);
00746             --outObjects;
00747         }
00748
00749         void onCreate(AbstractProduct * const pProduct)
00750         {
00751             CP::onCreate();
00752             SP::onCreate();
00753             EP::onCreate(pProduct);
00754         }
00755
00756         void onDestroy(AbstractProduct * const pProduct)
00757         {
00758             CP::onDestroy();
00759             SP::onDestroy();
00760             EP::onDestroy(pProduct);
00761         }
00762
00763           // delete the object
00764           template<class T> struct deleteObject : public std::unary_function<T, void>
00765           {
00766                void operator()(T x){ delete x; }
00767           };
00768
00769           // delete the objects in the vector
00770           template<class T> struct deleteVectorObjects : public std::unary_function<T, void>
00771           {
00772                void operator()(T x){
00773                     ObjVector &vec(x.second);
00774                     std::for_each(vec.begin(), vec.end(), deleteObject< typename ObjVector::value_type>());
00775                }
00776           };
00777
00778           // delete the keys of the map
00779           template<class T> struct deleteMapKeys : public std::unary_function<T, void>
00780           {
00781                void operator()(T x){ delete x.first; }
00782           };
00783
00784      protected:
00785         virtual void remove(AbstractProduct * const pProduct)
00786         {
00787             typename FetchedObjToKeyMap::iterator fetchedItr = providedObjects.find(pProduct);
00788             if(fetchedItr!=providedObjects.end()) // object is unreleased.
00789                 throw CacheException();
00790             bool productRemoved = false;
00791             typename KeyToObjVectorMap::iterator objVectorItr;
00792             typename ObjVector::iterator objItr;
00793             for(objVectorItr=fromKeyToObjVector.begin();objVectorItr!=fromKeyToObjVector.end();++objVectorItr)
00794             {
00795                 ObjVector &v((*objVectorItr).second);
00796                 objItr = remove_if(v.begin(), v.end(), std::bind2nd(std::equal_to<AbstractProduct*>(), pProduct));
00797                 if(objItr != v.end()) // we found the vector containing pProduct and removed it
00798                 {
00799                     onDestroy(pProduct); // warning policies we are about to destroy an object
00800                     v.erase(objItr, v.end()); // real removing
00801                     productRemoved = true;
00802                     break;
00803                 }
00804             }
00805             if(productRemoved==false)
00806                 throw CacheException(); // the product is not in the cache ?!
00807             delete pProduct; // deleting it
00808         }
00809
00810      public:
00811         CachedFactory() : factory(), fromKeyToObjVector(), providedObjects(), outObjects(0)
00812         {
00813         }
00814
00815         ~CachedFactory()
00816         {
00817           using namespace std;
00818             // debug information
00819             SP::onDebug();
00820             // cleaning the Cache
00821             for_each(fromKeyToObjVector.begin(), fromKeyToObjVector.end(),
00822                deleteVectorObjects< typename KeyToObjVectorMap::value_type >()
00823             );
00824             if(!providedObjects.empty())
00825             {
00826                     // The factory is responsible for the creation and destruction of objects.
00827                     // If objects are out during the destruction of the Factory : deleting anyway.
00828                     // This might not be a good idea. But throwing an exception in a destructor is
00829                     // considered as a bad pratice and asserting might be too much.
00830                     // What to do ? Leaking memory or corrupting in use pointers ? hmm...
00831                 D( cout << "====>>  Cache destructor : deleting "<< providedObjects.size()<<" in use objects  <<====" << endl << endl; )
00832                 for_each(providedObjects.begin(), providedObjects.end(),
00833                      deleteMapKeys< typename FetchedObjToKeyMap::value_type >()
00834                 );
00835             }
00836         }
00837
00839         // Acts as the proxy pattern and //
00840         // forwards factory methods      //
00842
00843         bool Register(const IdentifierType& id, ProductCreator creator)
00844         {
00845             return factory.Register(id, creator);
00846         }
00847
00848         template <class PtrObj, typename CreaFn>
00849         bool Register(const IdentifierType& id, const PtrObj& p, CreaFn fn)
00850         {
00851             return factory.Register(id, p, fn);
00852         }
00853
00854         bool Unregister(const IdentifierType& id)
00855         {
00856             return factory.Unregister(id);
00857         }
00858
00860         std::vector<IdentifierType>& RegisteredIds()
00861         {
00862             return factory.RegisteredIds();
00863         }
00864
00865         ProductReturn CreateObject(const IdentifierType& id)
00866         {
00867             Key key(id);
00868             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00869             if(shouldCreateObject(pProduct))
00870             {
00871                 pProduct = factory.CreateObject(key.id);
00872                 onCreate(pProduct);
00873             }
00874             onFetch(pProduct);
00875             providedObjects[pProduct] = key;
00876             return NP::encapsulate(pProduct);
00877         }
00878
00879         ProductReturn CreateObject(const IdentifierType& id,
00880                         Parm1 p1)
00881         {
00882             Key key(id,p1);
00883             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00884             if(shouldCreateObject(pProduct))
00885             {
00886                 pProduct = factory.CreateObject(key.id,key.p1);
00887                 onCreate(pProduct);
00888             }
00889             onFetch(pProduct);
00890             providedObjects[pProduct] = key;
00891             return NP::encapsulate(pProduct);
00892         }
00893
00894         ProductReturn CreateObject(const IdentifierType& id,
00895                         Parm1 p1, Parm2 p2)
00896         {
00897             Key key(id,p1,p2);
00898             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00899             if(shouldCreateObject(pProduct))
00900             {
00901                 pProduct = factory.CreateObject(key.id,key.p1,key.p2);
00902                 onCreate(pProduct);
00903             }
00904             onFetch(pProduct);
00905             providedObjects[pProduct] = key;
00906             return NP::encapsulate(pProduct);
00907         }
00908
00909         ProductReturn CreateObject(const IdentifierType& id,
00910                         Parm1 p1, Parm2 p2, Parm3 p3)
00911         {
00912             Key key(id,p1,p2,p3);
00913             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00914             if(shouldCreateObject(pProduct))
00915             {
00916                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3);
00917                 onCreate(pProduct);
00918             }
00919             onFetch(pProduct);
00920             providedObjects[pProduct] = key;
00921             return NP::encapsulate(pProduct);
00922         }
00923
00924         ProductReturn CreateObject(const IdentifierType& id,
00925                         Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
00926         {
00927             Key key(id,p1,p2,p3,p4);
00928             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00929             if(shouldCreateObject(pProduct))
00930             {
00931                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
00932                 ,key.p4);
00933                 onCreate(pProduct);
00934             }
00935             onFetch(pProduct);
00936             providedObjects[pProduct] = key;
00937             return NP::encapsulate(pProduct);
00938         }
00939
00940         ProductReturn CreateObject(const IdentifierType& id,
00941                         Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
00942         {
00943             Key key(id,p1,p2,p3,p4,p5);
00944             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00945             if(shouldCreateObject(pProduct))
00946             {
00947                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
00948                 ,key.p4,key.p5);
00949                 onCreate(pProduct);
00950             }
00951             onFetch(pProduct);
00952             providedObjects[pProduct] = key;
00953             return NP::encapsulate(pProduct);
00954         }
00955
00956         ProductReturn CreateObject(const IdentifierType& id,
00957                         Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00958                         Parm6 p6)
00959         {
00960             Key key(id,p1,p2,p3,p4,p5,p6);
00961             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00962             if(shouldCreateObject(pProduct))
00963             {
00964                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
00965                 ,key.p4,key.p5,key.p6);
00966                 onCreate(pProduct);
00967             }
00968             onFetch(pProduct);
00969             providedObjects[pProduct] = key;
00970             return NP::encapsulate(pProduct);
00971         }
00972
00973         ProductReturn CreateObject(const IdentifierType& id,
00974                         Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00975                         Parm6 p6, Parm7 p7 )
00976         {
00977             Key key(id,p1,p2,p3,p4,p5,p6,p7);
00978             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00979             if(shouldCreateObject(pProduct))
00980             {
00981                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
00982                 ,key.p4,key.p5,key.p6,key.p7);
00983                 onCreate(pProduct);
00984             }
00985             onFetch(pProduct);
00986             providedObjects[pProduct] = key;
00987             return NP::encapsulate(pProduct);
00988         }
00989
00990         ProductReturn CreateObject(const IdentifierType& id,
00991                         Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00992                         Parm6 p6, Parm7 p7, Parm8 p8)
00993         {
00994             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8);
00995             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
00996             if(shouldCreateObject(pProduct))
00997             {
00998                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
00999                 ,key.p4,key.p5,key.p6,key.p7,key.p8);
01000                 onCreate(pProduct);
01001             }
01002             onFetch(pProduct);
01003             providedObjects[pProduct] = key;
01004             return NP::encapsulate(pProduct);
01005         }
01006
01007         ProductReturn CreateObject(const IdentifierType& id,
01008                         Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01009                         Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
01010         {
01011             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9);
01012             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
01013             if(shouldCreateObject(pProduct))
01014             {
01015                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
01016                 ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9);
01017                 onCreate(pProduct);
01018             }
01019             onFetch(pProduct);
01020             providedObjects[pProduct] = key;
01021             return NP::encapsulate(pProduct);
01022         }
01023
01024         ProductReturn CreateObject(const IdentifierType& id,
01025                         Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01026                         Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9,Parm10 p10)
01027         {
01028             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10);
01029             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
01030             if(shouldCreateObject(pProduct))
01031             {
01032                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
01033                 ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10);
01034                 onCreate(pProduct);
01035             }
01036             onFetch(pProduct);
01037             providedObjects[pProduct] = key;
01038             return NP::encapsulate(pProduct);
01039         }
01040
01041         ProductReturn CreateObject(const IdentifierType& id,
01042                         Parm1  p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5  p5,
01043                         Parm6  p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10,
01044                         Parm11 p11)
01045         {
01046             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11);
01047             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
01048             if(shouldCreateObject(pProduct))
01049             {
01050                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
01051                 ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11);
01052                 onCreate(pProduct);
01053             }
01054             onFetch(pProduct);
01055             providedObjects[pProduct] = key;
01056             return NP::encapsulate(pProduct);
01057         }
01058
01059         ProductReturn CreateObject(const IdentifierType& id,
01060                         Parm1  p1,  Parm2  p2, Parm3 p3, Parm4 p4, Parm5  p5,
01061                         Parm6  p6,  Parm7  p7, Parm8 p8, Parm9 p9, Parm10 p10,
01062                         Parm11 p11, Parm12 p12)
01063         {
01064             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12);
01065             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
01066             if(shouldCreateObject(pProduct))
01067             {
01068                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
01069                 ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12);
01070                 onCreate(pProduct);
01071             }
01072             onFetch(pProduct);
01073             providedObjects[pProduct] = key;
01074             return NP::encapsulate(pProduct);
01075         }
01076
01077         ProductReturn CreateObject(const IdentifierType& id,
01078                         Parm1  p1,  Parm2  p2,  Parm3  p3, Parm4 p4, Parm5  p5,
01079                         Parm6  p6,  Parm7  p7,  Parm8  p8, Parm9 p9, Parm10 p10,
01080                         Parm11 p11, Parm12 p12, Parm13 p13)
01081         {
01082             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13);
01083             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
01084             if(shouldCreateObject(pProduct))
01085             {
01086                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
01087                 ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12
01088                 ,key.p13);
01089                 onCreate(pProduct);
01090             }
01091             onFetch(pProduct);
01092             providedObjects[pProduct] = key;
01093             return NP::encapsulate(pProduct);
01094         }
01095
01096         ProductReturn CreateObject(const IdentifierType& id,
01097                         Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4, Parm5  p5,
01098                         Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9, Parm10 p10,
01099                         Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
01100         {
01101             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14);
01102             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
01103             if(shouldCreateObject(pProduct))
01104             {
01105                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
01106                 ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12
01107                 ,key.p13,key.p14);
01108                 onCreate(pProduct);
01109             }
01110             onFetch(pProduct);
01111             providedObjects[pProduct] = key;
01112             return NP::encapsulate(pProduct);
01113         }
01114
01115         ProductReturn CreateObject(const IdentifierType& id,
01116                         Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4,  Parm5  p5,
01117                         Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9,  Parm10 p10,
01118                         Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
01119         {
01120             Key key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15);
01121             AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
01122             if(shouldCreateObject(pProduct))
01123             {
01124                 pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3
01125                 ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12
01126                 ,key.p13,key.p14,key.p15);
01127                 onCreate(pProduct);
01128             }
01129             onFetch(pProduct);
01130             providedObjects[pProduct] = key;
01131             return NP::encapsulate(pProduct);
01132         }
01133
01135
01140         void ReleaseObject(ProductReturn &object)
01141         {
01142             AbstractProduct* pProduct(NP::release(object));
01143             typename FetchedObjToKeyMap::iterator itr = providedObjects.find(pProduct);
01144             if(itr == providedObjects.end())
01145                 throw CacheException();
01146             onRelease(pProduct);
01147             ReleaseObjectFromContainer(getContainerFromKey((*itr).second), pProduct);
01148             providedObjects.erase(itr);
01149         }
01150
01152         void displayCacheType()
01153         {
01154           using namespace std;
01155             cout << "############################" << endl;
01156             cout << "## Cache configuration" << endl;
01157             cout << "## + Encapsulation " << NP::name() << endl;
01158             cout << "## + Creating      " << CP::name() << endl;
01159             cout << "## + Eviction      " << EP::name() << endl;
01160             cout << "## + Statistics    " << SP::name() << endl;
01161             cout << "############################" << endl;
01162         }
01163      };
01164 } // namespace Loki
01165
01166 #endif // end file guardian
01167
Generated on Sat Jul 7 15:11:00 2007 for Loki by doxygen 1.5.1-p1


Loki: ConstPolicy.h Source File

ConstPolicy.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 Richard Sposato
00004 // Copyright (c) 2006 Peter Kümmel
00005 // Permission to use, copy, modify, distribute and sell this software for any
00006 //     purpose is hereby granted without fee, provided that the above copyright
00007 //     notice appear in all copies and that both that copyright notice and this
00008 //     permission notice appear in supporting documentation.
00009 // The authors make no representations about the
00010 //     suitability of this software for any purpose. It is provided "as is"
00011 //     without express or implied warranty.
00013 #ifndef LOKI_CONST_POLICY_INC_
00014 #define LOKI_CONST_POLICY_INC_
00015
00016 // $Id: ConstPolicy.h 769 2006-10-26 10:58:19Z syntheticpp $
00017
00018
00019 namespace Loki
00020 {
00021
00026
00027
00034
00035     template< class T >
00036     struct DontPropagateConst
00037     {
00038         typedef T Type;
00039     };
00040
00047
00048     template< class T >
00049     struct PropagateConst
00050     {
00051         typedef const T Type;
00052     };
00053
00054 // default will not break existing code
00055 #ifndef LOKI_DEFAULT_CONSTNESS
00056 #define LOKI_DEFAULT_CONSTNESS ::Loki::DontPropagateConst
00057 #endif
00058
00059 } // end namespace Loki
00060
00061 #endif // end file guardian
Generated on Sat Jul 7 15:11:00 2007 for Loki by doxygen 1.5.1-p1


Loki: DataGenerators.h Source File

DataGenerators.h

00001
00002 // The Loki Library
00003 // Data Generator by Shannon Barber
00004 // This code DOES NOT accompany the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 //
00008 // Code covered by the MIT License
00009 // The author makes no representations about the suitability of this software
00010 //  for any purpose. It is provided "as is" without express or implied warranty.
00012 #ifndef LOKI_DATAGENERATORS_INC_
00013 #define LOKI_DATAGENERATORS_INC_
00014
00015 // $Id: DataGenerators.h 751 2006-10-17 19:50:37Z syntheticpp $
00016
00017
00018 #include "Typelist.h"
00019
00020 //Reference version
00021
00022 /************************************************************************************
00023 // class template GenData
00024 // Iteratates a Typelist, and invokes the functor GenFunc<T>
00025 // for each type in the list, passing a functor along the way.
00026 // The functor is designed to be an insertion iterator which GenFunc<T>
00027 // can use to output information about the types in the list.
00028 //
00029
00030 Example Use
00031
00032 template<typename T>
00033 struct ExtractDataType
00034     {
00035     some_type operator()()
00036         {
00037         return create_value_from_type<T>;
00038         }
00039     };
00040
00041 Loki::IterateTypes<parameter_tl, ExtractDataType> gendata;
00042 std::vector<some_type> stuff;
00043 gendata(std::back_inserter(stuff));
00044 *******************************************************************************/
00045 namespace Loki
00046 {
00047     namespace TL
00048         {
00049         template<typename T>
00050         struct nameof_type
00051             {
00052             const char* operator()()
00053                 {
00054                 return typeid(T).name();
00055                 }
00056             };
00057         template<typename T>
00058         struct sizeof_type
00059             {
00060             size_t operator()()
00061                 {
00062                 return sizeof(T);
00063                 }
00064             };
00065     template <class TList, template <class> class GenFunc>
00066     struct IterateTypes;
00067
00068     template <class T1, class T2, template <class> class GenFunc>
00069     struct IterateTypes<Typelist<T1, T2>, GenFunc>
00070     {
00071     typedef IterateTypes<T1, GenFunc> head_t;
00072     head_t head;
00073     typedef IterateTypes<T2, GenFunc> tail_t;
00074     tail_t tail;
00075     template<class II>
00076     void operator()(II ii)
00077         {
00078         head.operator()(ii);
00079         tail.operator()(ii);
00080         }
00081     };
00082
00083     template <class AtomicType, template <class> class GenFunc>
00084     struct IterateTypes
00085     {
00086     template<class II>
00087     void operator()(II ii)
00088         {
00089         GenFunc<AtomicType> genfunc;
00090         *ii = genfunc();
00091         ++ii; //Is this even needed?
00092         }
00093     };
00094
00095     template <template <class> class GenFunc>
00096     struct IterateTypes<NullType, GenFunc>
00097     {
00098     template<class II>
00099     void operator()(II ii)
00100         {}
00101     };
00102
00103     template<typename Types, template <class> class UnitFunc, typename II>
00104     void iterate_types(II ii)
00105         {
00106         Loki::TL::IterateTypes<Types, UnitFunc> it;
00107         it(ii);
00108         }
00109     }//ns TL
00110 }//ns Loki
00111
00112 #endif // end file guardian
00113
Generated on Sat Jul 7 15:11:00 2007 for Loki by doxygen 1.5.1-p1


Loki: EmptyType.h Source File

EmptyType.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_EMPTYTYPE_INC_
00016 #define LOKI_EMPTYTYPE_INC_
00017
00018 // $Id: EmptyType.h 751 2006-10-17 19:50:37Z syntheticpp $
00019
00020
00021 namespace Loki
00022 {
00024 // class EmptyType
00025 // Used as a class type that doesn't hold anything
00026 // Useful as a strawman class
00028
00029     class EmptyType {};
00030
00031
00032     inline bool operator==(const EmptyType&, const EmptyType&)
00033     {
00034         return true;
00035     }
00036
00037     inline bool operator<(const EmptyType&, const EmptyType&)
00038     {
00039         return false;
00040     }
00041
00042     inline bool operator>(const EmptyType&, const EmptyType&)
00043     {
00044         return false;
00045     }
00046 }
00047
00048 #endif // end file guardian
00049
Generated on Sat Jul 7 15:11:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Factory.h Source File

Factory.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // Copyright (c) 2005 by Peter Kuemmel
00005 // This code DOES NOT accompany the book:
00006 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00007 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00008 //
00009 // Code covered by the MIT License
00010 // The authors make no representations about the suitability of this software
00011 // for any purpose. It is provided "as is" without express or implied warranty.
00013 #ifndef LOKI_FACTORYPARM_INC_
00014 #define LOKI_FACTORYPARM_INC_
00015
00016 // $Id: Factory.h 788 2006-11-24 22:30:54Z clitte_bbt $
00017
00018
00019 #include "LokiTypeInfo.h"
00020 #include "Functor.h"
00021 #include "AssocVector.h"
00022 #include "SmallObj.h"
00023 #include "Sequence.h"
00024
00025 #ifdef _MSC_VER
00026 #pragma warning(push)
00027 #pragma warning(disable: 4702)
00028 //unreachable code if OnUnknownType throws an exception
00029 #endif
00030
00076 namespace Loki
00077 {
00078
00090     template <typename IdentifierType, class AbstractProduct>
00091     struct DefaultFactoryError
00092     {
00093         struct Exception : public std::exception
00094         {
00095             const char* what() const throw() { return "Unknown Type"; }
00096         };
00097
00098         static AbstractProduct* OnUnknownType(IdentifierType)
00099         {
00100             throw Exception();
00101         }
00102     };
00103
00104
00105 #define LOKI_ENABLE_NEW_FACTORY_CODE
00106 #ifdef LOKI_ENABLE_NEW_FACTORY_CODE
00107
00108
00110 // class template FunctorImpl
00112
00113     struct FactoryImplBase
00114     {
00115         typedef EmptyType Parm1;
00116         typedef EmptyType Parm2;
00117         typedef EmptyType Parm3;
00118         typedef EmptyType Parm4;
00119         typedef EmptyType Parm5;
00120         typedef EmptyType Parm6;
00121         typedef EmptyType Parm7;
00122         typedef EmptyType Parm8;
00123         typedef EmptyType Parm9;
00124         typedef EmptyType Parm10;
00125         typedef EmptyType Parm11;
00126         typedef EmptyType Parm12;
00127         typedef EmptyType Parm13;
00128         typedef EmptyType Parm14;
00129         typedef EmptyType Parm15;
00130     };
00131
00132     template <typename AP, typename Id, typename TList >
00133     struct FactoryImpl;
00134
00135     template<typename AP, typename Id>
00136     struct FactoryImpl<AP, Id, NullType>
00137                 : public FactoryImplBase
00138     {
00139         virtual ~FactoryImpl() {}
00140         virtual AP* CreateObject(const Id & id ) = 0;
00141     };
00142 template <typename AP, typename Id, typename P1 >
00143     struct FactoryImpl<AP,Id, Seq<P1> >
00144                 : public FactoryImplBase
00145     {
00146         typedef typename TypeTraits<P1>::ParameterType Parm1;
00147         virtual ~FactoryImpl() {}
00148         virtual AP* CreateObject(const Id& id,Parm1 ) = 0;
00149     };
00150
00151     template<typename AP, typename Id, typename P1,typename P2 >
00152     struct FactoryImpl<AP, Id, Seq<P1, P2> >
00153                 : public FactoryImplBase
00154     {
00155         typedef typename TypeTraits<P1>::ParameterType Parm1;
00156         typedef typename TypeTraits<P2>::ParameterType Parm2;
00157         virtual ~FactoryImpl() {}
00158         virtual AP* CreateObject(const Id& id,Parm1, Parm2 ) = 0;
00159     };
00160
00161     template<typename AP, typename Id, typename P1,typename P2,typename P3 >
00162     struct FactoryImpl<AP, Id, Seq<P1, P2, P3> >
00163                 : public FactoryImplBase
00164     {
00165         typedef typename TypeTraits<P1>::ParameterType Parm1;
00166         typedef typename TypeTraits<P2>::ParameterType Parm2;
00167         typedef typename TypeTraits<P3>::ParameterType Parm3;
00168         virtual ~FactoryImpl() {}
00169         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3 ) = 0;
00170     };
00171
00172     template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 >
00173     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4> >
00174                 : public FactoryImplBase
00175     {
00176         typedef typename TypeTraits<P1>::ParameterType Parm1;
00177         typedef typename TypeTraits<P2>::ParameterType Parm2;
00178         typedef typename TypeTraits<P3>::ParameterType Parm3;
00179         typedef typename TypeTraits<P4>::ParameterType Parm4;
00180         virtual ~FactoryImpl() {}
00181         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4 ) = 0;
00182     };
00183
00184     template<typename AP, typename Id,
00185     typename P1,typename P2,typename P3,typename P4,typename P5 >
00186     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5> >
00187                 : public FactoryImplBase
00188     {
00189         typedef typename TypeTraits<P1>::ParameterType Parm1;
00190         typedef typename TypeTraits<P2>::ParameterType Parm2;
00191         typedef typename TypeTraits<P3>::ParameterType Parm3;
00192         typedef typename TypeTraits<P4>::ParameterType Parm4;
00193         typedef typename TypeTraits<P5>::ParameterType Parm5;
00194         virtual ~FactoryImpl() {}
00195         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
00196     };
00197
00198     template<typename AP, typename Id,
00199     typename P1,typename P2,typename P3,typename P4,typename P5,
00200     typename P6>
00201     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6> >
00202                 : public FactoryImplBase
00203     {
00204         typedef typename TypeTraits<P1>::ParameterType Parm1;
00205         typedef typename TypeTraits<P2>::ParameterType Parm2;
00206         typedef typename TypeTraits<P3>::ParameterType Parm3;
00207         typedef typename TypeTraits<P4>::ParameterType Parm4;
00208         typedef typename TypeTraits<P5>::ParameterType Parm5;
00209         typedef typename TypeTraits<P6>::ParameterType Parm6;
00210         virtual ~FactoryImpl() {}
00211         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00212                                 Parm6 )
00213         = 0;
00214     };
00215
00216     template<typename AP, typename Id,
00217     typename P1,typename P2,typename P3,typename P4,typename P5,
00218     typename P6,typename P7>
00219     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7> >
00220                 : public FactoryImplBase
00221     {
00222         typedef typename TypeTraits<P1>::ParameterType Parm1;
00223         typedef typename TypeTraits<P2>::ParameterType Parm2;
00224         typedef typename TypeTraits<P3>::ParameterType Parm3;
00225         typedef typename TypeTraits<P4>::ParameterType Parm4;
00226         typedef typename TypeTraits<P5>::ParameterType Parm5;
00227         typedef typename TypeTraits<P6>::ParameterType Parm6;
00228         typedef typename TypeTraits<P7>::ParameterType Parm7;
00229         virtual ~FactoryImpl() {}
00230         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00231                                 Parm6, Parm7 )
00232         = 0;
00233     };
00234
00235     template<typename AP, typename Id,
00236     typename P1,typename P2,typename P3,typename P4,typename P5,
00237     typename P6,typename P7,typename P8>
00238     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8> >
00239                 : public FactoryImplBase
00240     {
00241         typedef typename TypeTraits<P1>::ParameterType Parm1;
00242         typedef typename TypeTraits<P2>::ParameterType Parm2;
00243         typedef typename TypeTraits<P3>::ParameterType Parm3;
00244         typedef typename TypeTraits<P4>::ParameterType Parm4;
00245         typedef typename TypeTraits<P5>::ParameterType Parm5;
00246         typedef typename TypeTraits<P6>::ParameterType Parm6;
00247         typedef typename TypeTraits<P7>::ParameterType Parm7;
00248         typedef typename TypeTraits<P8>::ParameterType Parm8;
00249         virtual ~FactoryImpl() {}
00250         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00251                                 Parm6, Parm7, Parm8)
00252         = 0;
00253     };
00254
00255     template<typename AP, typename Id,
00256     typename P1,typename P2,typename P3,typename P4,typename P5,
00257     typename P6,typename P7,typename P8,typename P9>
00258     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9> >
00259                 : public FactoryImplBase
00260     {
00261         typedef typename TypeTraits<P1>::ParameterType Parm1;
00262         typedef typename TypeTraits<P2>::ParameterType Parm2;
00263         typedef typename TypeTraits<P3>::ParameterType Parm3;
00264         typedef typename TypeTraits<P4>::ParameterType Parm4;
00265         typedef typename TypeTraits<P5>::ParameterType Parm5;
00266         typedef typename TypeTraits<P6>::ParameterType Parm6;
00267         typedef typename TypeTraits<P7>::ParameterType Parm7;
00268         typedef typename TypeTraits<P8>::ParameterType Parm8;
00269         typedef typename TypeTraits<P9>::ParameterType Parm9;
00270         virtual ~FactoryImpl() {}
00271         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00272                                 Parm6, Parm7, Parm8, Parm9)
00273         = 0;
00274     };
00275
00276     template<typename AP, typename Id,
00277     typename P1,typename P2,typename P3,typename P4,typename P5,
00278     typename P6,typename P7,typename P8,typename P9,typename P10>
00279     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >
00280                 : public FactoryImplBase
00281     {
00282         typedef typename TypeTraits<P1>::ParameterType Parm1;
00283         typedef typename TypeTraits<P2>::ParameterType Parm2;
00284         typedef typename TypeTraits<P3>::ParameterType Parm3;
00285         typedef typename TypeTraits<P4>::ParameterType Parm4;
00286         typedef typename TypeTraits<P5>::ParameterType Parm5;
00287         typedef typename TypeTraits<P6>::ParameterType Parm6;
00288         typedef typename TypeTraits<P7>::ParameterType Parm7;
00289         typedef typename TypeTraits<P8>::ParameterType Parm8;
00290         typedef typename TypeTraits<P9>::ParameterType Parm9;
00291         typedef typename TypeTraits<P10>::ParameterType Parm10;
00292         virtual ~FactoryImpl() {}
00293         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00294                                 Parm6, Parm7, Parm8, Parm9,Parm10)
00295         = 0;
00296     };
00297
00298     template<typename AP, typename Id,
00299     typename P1,typename P2,typename P3,typename P4,typename P5,
00300     typename P6,typename P7,typename P8,typename P9,typename P10,
00301     typename P11>
00302     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >
00303                 : public FactoryImplBase
00304     {
00305         typedef typename TypeTraits<P1>::ParameterType Parm1;
00306         typedef typename TypeTraits<P2>::ParameterType Parm2;
00307         typedef typename TypeTraits<P3>::ParameterType Parm3;
00308         typedef typename TypeTraits<P4>::ParameterType Parm4;
00309         typedef typename TypeTraits<P5>::ParameterType Parm5;
00310         typedef typename TypeTraits<P6>::ParameterType Parm6;
00311         typedef typename TypeTraits<P7>::ParameterType Parm7;
00312         typedef typename TypeTraits<P8>::ParameterType Parm8;
00313         typedef typename TypeTraits<P9>::ParameterType Parm9;
00314         typedef typename TypeTraits<P10>::ParameterType Parm10;
00315         typedef typename TypeTraits<P11>::ParameterType Parm11;
00316         virtual ~FactoryImpl() {}
00317         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00318                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00319                                 Parm11)
00320         = 0;
00321     };
00322
00323     template<typename AP, typename Id,
00324     typename P1,typename P2,typename P3,typename P4,typename P5,
00325     typename P6,typename P7,typename P8,typename P9,typename P10,
00326     typename P11,typename P12>
00327     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >
00328                 : public FactoryImplBase
00329     {
00330         typedef typename TypeTraits<P1>::ParameterType Parm1;
00331         typedef typename TypeTraits<P2>::ParameterType Parm2;
00332         typedef typename TypeTraits<P3>::ParameterType Parm3;
00333         typedef typename TypeTraits<P4>::ParameterType Parm4;
00334         typedef typename TypeTraits<P5>::ParameterType Parm5;
00335         typedef typename TypeTraits<P6>::ParameterType Parm6;
00336         typedef typename TypeTraits<P7>::ParameterType Parm7;
00337         typedef typename TypeTraits<P8>::ParameterType Parm8;
00338         typedef typename TypeTraits<P9>::ParameterType Parm9;
00339         typedef typename TypeTraits<P10>::ParameterType Parm10;
00340         typedef typename TypeTraits<P11>::ParameterType Parm11;
00341         typedef typename TypeTraits<P12>::ParameterType Parm12;
00342         virtual ~FactoryImpl() {}
00343         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00344                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00345                                 Parm11,Parm12)
00346         = 0;
00347     };
00348
00349     template<typename AP, typename Id,
00350     typename P1,typename P2,typename P3,typename P4,typename P5,
00351     typename P6,typename P7,typename P8,typename P9,typename P10,
00352     typename P11,typename P12,typename P13>
00353     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >
00354                 : public FactoryImplBase
00355     {
00356         typedef typename TypeTraits<P1>::ParameterType Parm1;
00357         typedef typename TypeTraits<P2>::ParameterType Parm2;
00358         typedef typename TypeTraits<P3>::ParameterType Parm3;
00359         typedef typename TypeTraits<P4>::ParameterType Parm4;
00360         typedef typename TypeTraits<P5>::ParameterType Parm5;
00361         typedef typename TypeTraits<P6>::ParameterType Parm6;
00362         typedef typename TypeTraits<P7>::ParameterType Parm7;
00363         typedef typename TypeTraits<P8>::ParameterType Parm8;
00364         typedef typename TypeTraits<P9>::ParameterType Parm9;
00365         typedef typename TypeTraits<P10>::ParameterType Parm10;
00366         typedef typename TypeTraits<P11>::ParameterType Parm11;
00367         typedef typename TypeTraits<P12>::ParameterType Parm12;
00368         typedef typename TypeTraits<P13>::ParameterType Parm13;
00369         virtual ~FactoryImpl() {}
00370         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00371                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00372                                 Parm11,Parm12,Parm13)
00373         = 0;
00374     };
00375
00376     template<typename AP, typename Id,
00377     typename P1,typename P2,typename P3,typename P4,typename P5,
00378     typename P6,typename P7,typename P8,typename P9,typename P10,
00379     typename P11,typename P12,typename P13,typename P14>
00380     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >
00381                 : public FactoryImplBase
00382     {
00383         typedef typename TypeTraits<P1>::ParameterType Parm1;
00384         typedef typename TypeTraits<P2>::ParameterType Parm2;
00385         typedef typename TypeTraits<P3>::ParameterType Parm3;
00386         typedef typename TypeTraits<P4>::ParameterType Parm4;
00387         typedef typename TypeTraits<P5>::ParameterType Parm5;
00388         typedef typename TypeTraits<P6>::ParameterType Parm6;
00389         typedef typename TypeTraits<P7>::ParameterType Parm7;
00390         typedef typename TypeTraits<P8>::ParameterType Parm8;
00391         typedef typename TypeTraits<P9>::ParameterType Parm9;
00392         typedef typename TypeTraits<P10>::ParameterType Parm10;
00393         typedef typename TypeTraits<P11>::ParameterType Parm11;
00394         typedef typename TypeTraits<P12>::ParameterType Parm12;
00395         typedef typename TypeTraits<P13>::ParameterType Parm13;
00396         typedef typename TypeTraits<P14>::ParameterType Parm14;
00397         virtual ~FactoryImpl() {}
00398         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00399                                 Parm6, Parm7, Parm8, Parm8,Parm10,
00400                                 Parm11,Parm12,Parm13,Parm14)
00401         = 0;
00402     };
00403
00404     template<typename AP, typename Id,
00405     typename P1,typename P2,typename P3,typename P4,typename P5,
00406     typename P6,typename P7,typename P8,typename P9,typename P10,
00407     typename P11,typename P12,typename P13,typename P14,typename P15 >
00408     struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >
00409                 : public FactoryImplBase
00410     {
00411         typedef typename TypeTraits<P1>::ParameterType Parm1;
00412         typedef typename TypeTraits<P2>::ParameterType Parm2;
00413         typedef typename TypeTraits<P3>::ParameterType Parm3;
00414         typedef typename TypeTraits<P4>::ParameterType Parm4;
00415         typedef typename TypeTraits<P5>::ParameterType Parm5;
00416         typedef typename TypeTraits<P6>::ParameterType Parm6;
00417         typedef typename TypeTraits<P7>::ParameterType Parm7;
00418         typedef typename TypeTraits<P8>::ParameterType Parm8;
00419         typedef typename TypeTraits<P9>::ParameterType Parm9;
00420         typedef typename TypeTraits<P10>::ParameterType Parm10;
00421         typedef typename TypeTraits<P11>::ParameterType Parm11;
00422         typedef typename TypeTraits<P12>::ParameterType Parm12;
00423         typedef typename TypeTraits<P13>::ParameterType Parm13;
00424         typedef typename TypeTraits<P14>::ParameterType Parm14;
00425         typedef typename TypeTraits<P15>::ParameterType Parm15;
00426         virtual ~FactoryImpl() {}
00427         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00428                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00429                                 Parm11,Parm12,Parm13,Parm14,Parm15 )
00430         = 0;
00431     };
00432
00433 #ifndef LOKI_DISABLE_TYPELIST_MACROS
00434
00435     template <typename AP, typename Id, typename P1 >
00436     struct FactoryImpl<AP,Id, LOKI_TYPELIST_1( P1 )>
00437                 : public FactoryImplBase
00438     {
00439         typedef typename TypeTraits<P1>::ParameterType Parm1;
00440         virtual ~FactoryImpl() {}
00441         virtual AP* CreateObject(const Id& id,Parm1 ) = 0;
00442     };
00443
00444     template<typename AP, typename Id, typename P1,typename P2 >
00445     struct FactoryImpl<AP, Id, LOKI_TYPELIST_2( P1, P2 )>
00446                 : public FactoryImplBase
00447     {
00448         typedef typename TypeTraits<P1>::ParameterType Parm1;
00449         typedef typename TypeTraits<P2>::ParameterType Parm2;
00450         virtual ~FactoryImpl() {}
00451         virtual AP* CreateObject(const Id& id,Parm1, Parm2 ) = 0;
00452     };
00453
00454     template<typename AP, typename Id, typename P1,typename P2,typename P3 >
00455     struct FactoryImpl<AP, Id, LOKI_TYPELIST_3( P1, P2, P3 )>
00456                 : public FactoryImplBase
00457     {
00458         typedef typename TypeTraits<P1>::ParameterType Parm1;
00459         typedef typename TypeTraits<P2>::ParameterType Parm2;
00460         typedef typename TypeTraits<P3>::ParameterType Parm3;
00461         virtual ~FactoryImpl() {}
00462         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3 ) = 0;
00463     };
00464
00465     template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 >
00466     struct FactoryImpl<AP, Id, LOKI_TYPELIST_4( P1, P2, P3, P4 )>
00467                 : public FactoryImplBase
00468     {
00469         typedef typename TypeTraits<P1>::ParameterType Parm1;
00470         typedef typename TypeTraits<P2>::ParameterType Parm2;
00471         typedef typename TypeTraits<P3>::ParameterType Parm3;
00472         typedef typename TypeTraits<P4>::ParameterType Parm4;
00473         virtual ~FactoryImpl() {}
00474         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4 ) = 0;
00475     };
00476
00477     template<typename AP, typename Id,
00478     typename P1,typename P2,typename P3,typename P4,typename P5 >
00479     struct FactoryImpl<AP, Id, LOKI_TYPELIST_5( P1, P2, P3, P4, P5 )>
00480                 : public FactoryImplBase
00481     {
00482         typedef typename TypeTraits<P1>::ParameterType Parm1;
00483         typedef typename TypeTraits<P2>::ParameterType Parm2;
00484         typedef typename TypeTraits<P3>::ParameterType Parm3;
00485         typedef typename TypeTraits<P4>::ParameterType Parm4;
00486         typedef typename TypeTraits<P5>::ParameterType Parm5;
00487         virtual ~FactoryImpl() {}
00488         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
00489     };
00490
00491     template<typename AP, typename Id,
00492     typename P1,typename P2,typename P3,typename P4,typename P5,
00493     typename P6>
00494     struct FactoryImpl<AP, Id, LOKI_TYPELIST_6( P1, P2, P3, P4, P5, P6 )>
00495                 : public FactoryImplBase
00496     {
00497         typedef typename TypeTraits<P1>::ParameterType Parm1;
00498         typedef typename TypeTraits<P2>::ParameterType Parm2;
00499         typedef typename TypeTraits<P3>::ParameterType Parm3;
00500         typedef typename TypeTraits<P4>::ParameterType Parm4;
00501         typedef typename TypeTraits<P5>::ParameterType Parm5;
00502         typedef typename TypeTraits<P6>::ParameterType Parm6;
00503         virtual ~FactoryImpl() {}
00504         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00505                                 Parm6 )
00506         = 0;
00507     };
00508
00509     template<typename AP, typename Id,
00510     typename P1,typename P2,typename P3,typename P4,typename P5,
00511     typename P6,typename P7>
00512     struct FactoryImpl<AP, Id, LOKI_TYPELIST_7( P1, P2, P3, P4, P5, P6, P7 )>
00513                 : public FactoryImplBase
00514     {
00515         typedef typename TypeTraits<P1>::ParameterType Parm1;
00516         typedef typename TypeTraits<P2>::ParameterType Parm2;
00517         typedef typename TypeTraits<P3>::ParameterType Parm3;
00518         typedef typename TypeTraits<P4>::ParameterType Parm4;
00519         typedef typename TypeTraits<P5>::ParameterType Parm5;
00520         typedef typename TypeTraits<P6>::ParameterType Parm6;
00521         typedef typename TypeTraits<P7>::ParameterType Parm7;
00522         virtual ~FactoryImpl() {}
00523         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00524                                 Parm6, Parm7 )
00525         = 0;
00526     };
00527
00528     template<typename AP, typename Id,
00529     typename P1,typename P2,typename P3,typename P4,typename P5,
00530     typename P6,typename P7,typename P8>
00531     struct FactoryImpl<AP, Id, LOKI_TYPELIST_8( P1, P2, P3, P4, P5, P6, P7, P8 )>
00532                 : public FactoryImplBase
00533     {
00534         typedef typename TypeTraits<P1>::ParameterType Parm1;
00535         typedef typename TypeTraits<P2>::ParameterType Parm2;
00536         typedef typename TypeTraits<P3>::ParameterType Parm3;
00537         typedef typename TypeTraits<P4>::ParameterType Parm4;
00538         typedef typename TypeTraits<P5>::ParameterType Parm5;
00539         typedef typename TypeTraits<P6>::ParameterType Parm6;
00540         typedef typename TypeTraits<P7>::ParameterType Parm7;
00541         typedef typename TypeTraits<P8>::ParameterType Parm8;
00542         virtual ~FactoryImpl() {}
00543         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00544                                 Parm6, Parm7, Parm8)
00545         = 0;
00546     };
00547
00548     template<typename AP, typename Id,
00549     typename P1,typename P2,typename P3,typename P4,typename P5,
00550     typename P6,typename P7,typename P8,typename P9>
00551     struct FactoryImpl<AP, Id, LOKI_TYPELIST_9( P1, P2, P3, P4, P5, P6, P7, P8, P9 )>
00552                 : public FactoryImplBase
00553     {
00554         typedef typename TypeTraits<P1>::ParameterType Parm1;
00555         typedef typename TypeTraits<P2>::ParameterType Parm2;
00556         typedef typename TypeTraits<P3>::ParameterType Parm3;
00557         typedef typename TypeTraits<P4>::ParameterType Parm4;
00558         typedef typename TypeTraits<P5>::ParameterType Parm5;
00559         typedef typename TypeTraits<P6>::ParameterType Parm6;
00560         typedef typename TypeTraits<P7>::ParameterType Parm7;
00561         typedef typename TypeTraits<P8>::ParameterType Parm8;
00562         typedef typename TypeTraits<P9>::ParameterType Parm9;
00563         virtual ~FactoryImpl() {}
00564         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00565                                 Parm6, Parm7, Parm8, Parm9)
00566         = 0;
00567     };
00568
00569     template<typename AP, typename Id,
00570     typename P1,typename P2,typename P3,typename P4,typename P5,
00571     typename P6,typename P7,typename P8,typename P9,typename P10>
00572     struct FactoryImpl<AP, Id, LOKI_TYPELIST_10( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 )>
00573                 : public FactoryImplBase
00574     {
00575         typedef typename TypeTraits<P1>::ParameterType Parm1;
00576         typedef typename TypeTraits<P2>::ParameterType Parm2;
00577         typedef typename TypeTraits<P3>::ParameterType Parm3;
00578         typedef typename TypeTraits<P4>::ParameterType Parm4;
00579         typedef typename TypeTraits<P5>::ParameterType Parm5;
00580         typedef typename TypeTraits<P6>::ParameterType Parm6;
00581         typedef typename TypeTraits<P7>::ParameterType Parm7;
00582         typedef typename TypeTraits<P8>::ParameterType Parm8;
00583         typedef typename TypeTraits<P9>::ParameterType Parm9;
00584         typedef typename TypeTraits<P10>::ParameterType Parm10;
00585         virtual ~FactoryImpl() {}
00586         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00587                                 Parm6, Parm7, Parm8, Parm9,Parm10)
00588         = 0;
00589     };
00590
00591     template<typename AP, typename Id,
00592     typename P1,typename P2,typename P3,typename P4,typename P5,
00593     typename P6,typename P7,typename P8,typename P9,typename P10,
00594     typename P11>
00595     struct FactoryImpl<AP, Id, LOKI_TYPELIST_11( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 )>
00596                 : public FactoryImplBase
00597     {
00598         typedef typename TypeTraits<P1>::ParameterType Parm1;
00599         typedef typename TypeTraits<P2>::ParameterType Parm2;
00600         typedef typename TypeTraits<P3>::ParameterType Parm3;
00601         typedef typename TypeTraits<P4>::ParameterType Parm4;
00602         typedef typename TypeTraits<P5>::ParameterType Parm5;
00603         typedef typename TypeTraits<P6>::ParameterType Parm6;
00604         typedef typename TypeTraits<P7>::ParameterType Parm7;
00605         typedef typename TypeTraits<P8>::ParameterType Parm8;
00606         typedef typename TypeTraits<P9>::ParameterType Parm9;
00607         typedef typename TypeTraits<P10>::ParameterType Parm10;
00608         typedef typename TypeTraits<P11>::ParameterType Parm11;
00609         virtual ~FactoryImpl() {}
00610         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00611                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00612                                 Parm11)
00613         = 0;
00614     };
00615
00616     template<typename AP, typename Id,
00617     typename P1,typename P2,typename P3,typename P4,typename P5,
00618     typename P6,typename P7,typename P8,typename P9,typename P10,
00619     typename P11,typename P12>
00620     struct FactoryImpl<AP, Id, LOKI_TYPELIST_12( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 )>
00621                 : public FactoryImplBase
00622     {
00623         typedef typename TypeTraits<P1>::ParameterType Parm1;
00624         typedef typename TypeTraits<P2>::ParameterType Parm2;
00625         typedef typename TypeTraits<P3>::ParameterType Parm3;
00626         typedef typename TypeTraits<P4>::ParameterType Parm4;
00627         typedef typename TypeTraits<P5>::ParameterType Parm5;
00628         typedef typename TypeTraits<P6>::ParameterType Parm6;
00629         typedef typename TypeTraits<P7>::ParameterType Parm7;
00630         typedef typename TypeTraits<P8>::ParameterType Parm8;
00631         typedef typename TypeTraits<P9>::ParameterType Parm9;
00632         typedef typename TypeTraits<P10>::ParameterType Parm10;
00633         typedef typename TypeTraits<P11>::ParameterType Parm11;
00634         typedef typename TypeTraits<P12>::ParameterType Parm12;
00635         virtual ~FactoryImpl() {}
00636         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00637                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00638                                 Parm11,Parm12)
00639         = 0;
00640     };
00641
00642     template<typename AP, typename Id,
00643     typename P1,typename P2,typename P3,typename P4,typename P5,
00644     typename P6,typename P7,typename P8,typename P9,typename P10,
00645     typename P11,typename P12,typename P13>
00646     struct FactoryImpl<AP, Id, LOKI_TYPELIST_13( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 )>
00647                 : public FactoryImplBase
00648     {
00649         typedef typename TypeTraits<P1>::ParameterType Parm1;
00650         typedef typename TypeTraits<P2>::ParameterType Parm2;
00651         typedef typename TypeTraits<P3>::ParameterType Parm3;
00652         typedef typename TypeTraits<P4>::ParameterType Parm4;
00653         typedef typename TypeTraits<P5>::ParameterType Parm5;
00654         typedef typename TypeTraits<P6>::ParameterType Parm6;
00655         typedef typename TypeTraits<P7>::ParameterType Parm7;
00656         typedef typename TypeTraits<P8>::ParameterType Parm8;
00657         typedef typename TypeTraits<P9>::ParameterType Parm9;
00658         typedef typename TypeTraits<P10>::ParameterType Parm10;
00659         typedef typename TypeTraits<P11>::ParameterType Parm11;
00660         typedef typename TypeTraits<P12>::ParameterType Parm12;
00661         typedef typename TypeTraits<P13>::ParameterType Parm13;
00662         virtual ~FactoryImpl() {}
00663         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00664                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00665                                 Parm11,Parm12,Parm13)
00666         = 0;
00667     };
00668
00669     template<typename AP, typename Id,
00670     typename P1,typename P2,typename P3,typename P4,typename P5,
00671     typename P6,typename P7,typename P8,typename P9,typename P10,
00672     typename P11,typename P12,typename P13,typename P14>
00673     struct FactoryImpl<AP, Id, LOKI_TYPELIST_14( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 )>
00674                 : public FactoryImplBase
00675     {
00676         typedef typename TypeTraits<P1>::ParameterType Parm1;
00677         typedef typename TypeTraits<P2>::ParameterType Parm2;
00678         typedef typename TypeTraits<P3>::ParameterType Parm3;
00679         typedef typename TypeTraits<P4>::ParameterType Parm4;
00680         typedef typename TypeTraits<P5>::ParameterType Parm5;
00681         typedef typename TypeTraits<P6>::ParameterType Parm6;
00682         typedef typename TypeTraits<P7>::ParameterType Parm7;
00683         typedef typename TypeTraits<P8>::ParameterType Parm8;
00684         typedef typename TypeTraits<P9>::ParameterType Parm9;
00685         typedef typename TypeTraits<P10>::ParameterType Parm10;
00686         typedef typename TypeTraits<P11>::ParameterType Parm11;
00687         typedef typename TypeTraits<P12>::ParameterType Parm12;
00688         typedef typename TypeTraits<P13>::ParameterType Parm13;
00689         typedef typename TypeTraits<P14>::ParameterType Parm14;
00690         virtual ~FactoryImpl() {}
00691         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00692                                 Parm6, Parm7, Parm8, Parm8,Parm10,
00693                                 Parm11,Parm12,Parm13,Parm14)
00694         = 0;
00695     };
00696
00697     template<typename AP, typename Id,
00698     typename P1,typename P2,typename P3,typename P4,typename P5,
00699     typename P6,typename P7,typename P8,typename P9,typename P10,
00700     typename P11,typename P12,typename P13,typename P14,typename P15 >
00701     struct FactoryImpl<AP, Id, LOKI_TYPELIST_15( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 )>
00702                 : public FactoryImplBase
00703     {
00704         typedef typename TypeTraits<P1>::ParameterType Parm1;
00705         typedef typename TypeTraits<P2>::ParameterType Parm2;
00706         typedef typename TypeTraits<P3>::ParameterType Parm3;
00707         typedef typename TypeTraits<P4>::ParameterType Parm4;
00708         typedef typename TypeTraits<P5>::ParameterType Parm5;
00709         typedef typename TypeTraits<P6>::ParameterType Parm6;
00710         typedef typename TypeTraits<P7>::ParameterType Parm7;
00711         typedef typename TypeTraits<P8>::ParameterType Parm8;
00712         typedef typename TypeTraits<P9>::ParameterType Parm9;
00713         typedef typename TypeTraits<P10>::ParameterType Parm10;
00714         typedef typename TypeTraits<P11>::ParameterType Parm11;
00715         typedef typename TypeTraits<P12>::ParameterType Parm12;
00716         typedef typename TypeTraits<P13>::ParameterType Parm13;
00717         typedef typename TypeTraits<P14>::ParameterType Parm14;
00718         typedef typename TypeTraits<P15>::ParameterType Parm15;
00719         virtual ~FactoryImpl() {}
00720         virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
00721                                 Parm6, Parm7, Parm8, Parm9,Parm10,
00722                                 Parm11,Parm12,Parm13,Parm14,Parm15 )
00723         = 0;
00724     };
00725
00726 #endif //LOKI_DISABLE_TYPELIST_MACROS
00727
00728
00745     template
00746     <
00747         class AbstractProduct,
00748         typename IdentifierType,
00749         typename CreatorParmTList = NullType,
00750         template<typename, class> class FactoryErrorPolicy = DefaultFactoryError
00751     >
00752     class Factory : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
00753     {
00754         typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl;
00755
00756         typedef typename Impl::Parm1 Parm1;
00757         typedef typename Impl::Parm2 Parm2;
00758         typedef typename Impl::Parm3 Parm3;
00759         typedef typename Impl::Parm4 Parm4;
00760         typedef typename Impl::Parm5 Parm5;
00761         typedef typename Impl::Parm6 Parm6;
00762         typedef typename Impl::Parm7 Parm7;
00763         typedef typename Impl::Parm8 Parm8;
00764         typedef typename Impl::Parm9 Parm9;
00765         typedef typename Impl::Parm10 Parm10;
00766         typedef typename Impl::Parm11 Parm11;
00767         typedef typename Impl::Parm12 Parm12;
00768         typedef typename Impl::Parm13 Parm13;
00769         typedef typename Impl::Parm14 Parm14;
00770         typedef typename Impl::Parm15 Parm15;
00771
00772         typedef Functor<AbstractProduct*, CreatorParmTList> ProductCreator;
00773
00774         typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
00775
00776         IdToProductMap associations_;
00777
00778     public:
00779
00780         Factory()
00781             : associations_()
00782         {
00783         }
00784
00785         ~Factory()
00786         {
00787             associations_.erase(associations_.begin(), associations_.end());
00788         }
00789
00790         bool Register(const IdentifierType& id, ProductCreator creator)
00791         {
00792             return associations_.insert(
00793                          typename IdToProductMap::value_type(id, creator)).second != 0;
00794         }
00795
00796         template <class PtrObj, typename CreaFn>
00797         bool Register(const IdentifierType& id, const PtrObj& p, CreaFn fn)
00798         {
00799             ProductCreator creator( p, fn );
00800             return associations_.insert(
00801                 typename IdToProductMap::value_type(id, creator)).second != 0;
00802         }
00803
00804         bool Unregister(const IdentifierType& id)
00805         {
00806             return associations_.erase(id) != 0;
00807         }
00808
00809         std::vector<IdentifierType> RegisteredIds()
00810         {
00811             std::vector<IdentifierType> ids;
00812             for(typename IdToProductMap::iterator it = associations_.begin();
00813                 it != associations_.end(); ++it)
00814             {
00815                 ids.push_back(it->first);
00816             }
00817             return ids;
00818         }
00819
00820         AbstractProduct* CreateObject(const IdentifierType& id)
00821         {
00822             typename IdToProductMap::iterator i = associations_.find(id);
00823             if (i != associations_.end())
00824                 return (i->second)( );
00825             return this->OnUnknownType(id);
00826         }
00827
00828         AbstractProduct* CreateObject(const IdentifierType& id,
00829                                             Parm1 p1)
00830         {
00831             typename IdToProductMap::iterator i = associations_.find(id);
00832             if (i != associations_.end())
00833                 return (i->second)( p1 );
00834             return this->OnUnknownType(id);
00835         }
00836
00837         AbstractProduct* CreateObject(const IdentifierType& id,
00838                                             Parm1 p1, Parm2 p2)
00839         {
00840             typename IdToProductMap::iterator i = associations_.find(id);
00841             if (i != associations_.end())
00842                 return (i->second)( p1,p2 );
00843             return this->OnUnknownType(id);
00844         }
00845
00846         AbstractProduct* CreateObject(const IdentifierType& id,
00847                                             Parm1 p1, Parm2 p2, Parm3 p3)
00848         {
00849             typename IdToProductMap::iterator i = associations_.find(id);
00850             if (i != associations_.end())
00851                 return (i->second)( p1,p2,p3 );
00852             return this->OnUnknownType(id);
00853         }
00854
00855         AbstractProduct* CreateObject(const IdentifierType& id,
00856                                             Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
00857         {
00858             typename IdToProductMap::iterator i = associations_.find(id);
00859             if (i != associations_.end())
00860                 return (i->second)( p1,p2,p3,p4 );
00861             return this->OnUnknownType(id);
00862         }
00863
00864         AbstractProduct* CreateObject(const IdentifierType& id,
00865                                             Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
00866         {
00867             typename IdToProductMap::iterator i = associations_.find(id);
00868             if (i != associations_.end())
00869                 return (i->second)( p1,p2,p3,p4,p5 );
00870             return this->OnUnknownType(id);
00871         }
00872
00873         AbstractProduct* CreateObject(const IdentifierType& id,
00874                                             Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00875                                             Parm6 p6)
00876         {
00877             typename IdToProductMap::iterator i = associations_.find(id);
00878             if (i != associations_.end())
00879                 return (i->second)( p1,p2,p3,p4,p5,p6 );
00880             return this->OnUnknownType(id);
00881         }
00882
00883         AbstractProduct* CreateObject(const IdentifierType& id,
00884                                             Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00885                                             Parm6 p6, Parm7 p7 )
00886         {
00887             typename IdToProductMap::iterator i = associations_.find(id);
00888             if (i != associations_.end())
00889                 return (i->second)( p1,p2,p3,p4,p5,p6,p7 );
00890             return this->OnUnknownType(id);
00891         }
00892
00893         AbstractProduct* CreateObject(const IdentifierType& id,
00894                                             Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00895                                             Parm6 p6, Parm7 p7, Parm8 p8)
00896         {
00897             typename IdToProductMap::iterator i = associations_.find(id);
00898             if (i != associations_.end())
00899                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8 );
00900             return this->OnUnknownType(id);
00901         }
00902
00903         AbstractProduct* CreateObject(const IdentifierType& id,
00904                                             Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00905                                             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
00906         {
00907             typename IdToProductMap::iterator i = associations_.find(id);
00908             if (i != associations_.end())
00909                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9 );
00910             return this->OnUnknownType(id);
00911         }
00912         AbstractProduct* CreateObject(const IdentifierType& id,
00913                                             Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00914                                             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9,Parm10 p10)
00915         {
00916             typename IdToProductMap::iterator i = associations_.find(id);
00917             if (i != associations_.end())
00918                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10 );
00919             return this->OnUnknownType(id);
00920         }
00921
00922         AbstractProduct* CreateObject(const IdentifierType& id,
00923                                             Parm1  p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5  p5,
00924                                             Parm6  p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10,
00925                                             Parm11 p11)
00926         {
00927             typename IdToProductMap::iterator i = associations_.find(id);
00928             if (i != associations_.end())
00929                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 );
00930             return this->OnUnknownType(id);
00931         }
00932
00933         AbstractProduct* CreateObject(const IdentifierType& id,
00934                                             Parm1  p1,  Parm2  p2, Parm3 p3, Parm4 p4, Parm5  p5,
00935                                             Parm6  p6,  Parm7  p7, Parm8 p8, Parm9 p9, Parm10 p10,
00936                                             Parm11 p11, Parm12 p12)
00937         {
00938             typename IdToProductMap::iterator i = associations_.find(id);
00939             if (i != associations_.end())
00940                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12 );
00941             return this->OnUnknownType(id);
00942         }
00943
00944         AbstractProduct* CreateObject(const IdentifierType& id,
00945                                             Parm1  p1,  Parm2  p2,  Parm3  p3, Parm4 p4, Parm5  p5,
00946                                             Parm6  p6,  Parm7  p7,  Parm8  p8, Parm9 p9, Parm10 p10,
00947                                             Parm11 p11, Parm12 p12, Parm13 p13)
00948         {
00949             typename IdToProductMap::iterator i = associations_.find(id);
00950             if (i != associations_.end())
00951                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13 );
00952             return this->OnUnknownType(id);
00953         }
00954
00955         AbstractProduct* CreateObject(const IdentifierType& id,
00956                                             Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4, Parm5  p5,
00957                                             Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9, Parm10 p10,
00958                                             Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
00959         {
00960             typename IdToProductMap::iterator i = associations_.find(id);
00961             if (i != associations_.end())
00962                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14 );
00963             return this->OnUnknownType(id);
00964         }
00965
00966         AbstractProduct* CreateObject(const IdentifierType& id,
00967                                             Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4,  Parm5  p5,
00968                                             Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9,  Parm10 p10,
00969                                             Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
00970         {
00971             typename IdToProductMap::iterator i = associations_.find(id);
00972             if (i != associations_.end())
00973                 return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15 );
00974             return this->OnUnknownType(id);
00975         }
00976
00977     };
00978
00979 #else
00980
00981     template
00982     <
00983         class AbstractProduct,
00984         typename IdentifierType,
00985         typename ProductCreator = AbstractProduct* (*)(),
00986         template<typename, class>
00987             class FactoryErrorPolicy = DefaultFactoryError
00988     >
00989     class Factory
00990         : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
00991     {
00992     public:
00993         bool Register(const IdentifierType& id, ProductCreator creator)
00994         {
00995             return associations_.insert(
00996                 typename IdToProductMap::value_type(id, creator)).second != 0;
00997         }
00998
00999         bool Unregister(const IdentifierType& id)
01000         {
01001             return associations_.erase(id) != 0;
01002         }
01003
01004         AbstractProduct* CreateObject(const IdentifierType& id)
01005         {
01006             typename IdToProductMap::iterator i = associations_.find(id);
01007             if (i != associations_.end())
01008             {
01009                 return (i->second)();
01010             }
01011             return this->OnUnknownType(id);
01012         }
01013
01014     private:
01015         typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
01016         IdToProductMap associations_;
01017     };
01018
01019 #endif //#define ENABLE_NEW_FACTORY_CODE
01020
01031     template
01032     <
01033         class AbstractProduct,
01034         class ProductCreator =
01035             AbstractProduct* (*)(const AbstractProduct*),
01036         template<typename, class>
01037             class FactoryErrorPolicy = DefaultFactoryError
01038     >
01039     class CloneFactory
01040         : public FactoryErrorPolicy<TypeInfo, AbstractProduct>
01041     {
01042     public:
01043         bool Register(const TypeInfo& ti, ProductCreator creator)
01044         {
01045             return associations_.insert(
01046                 typename IdToProductMap::value_type(ti, creator)).second != 0;
01047         }
01048
01049         bool Unregister(const TypeInfo& id)
01050         {
01051             return associations_.erase(id) != 0;
01052         }
01053
01054         AbstractProduct* CreateObject(const AbstractProduct* model)
01055         {
01056             if (model == NULL)
01057             {
01058                return NULL;
01059             }
01060
01061             typename IdToProductMap::iterator i =
01062                associations_.find(typeid(*model));
01063
01064             if (i != associations_.end())
01065             {
01066                 return (i->second)(model);
01067             }
01068             return this->OnUnknownType(typeid(*model));
01069         }
01070
01071     private:
01072         typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
01073         IdToProductMap associations_;
01074     };
01075
01076 } // namespace Loki
01077
01078
01079 #ifdef _MSC_VER
01080 #pragma warning( pop )
01081 #endif
01082
01083 #endif // end file guardian
01084
Generated on Sat Jul 7 15:11:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Function.h Source File

Function.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2005 Peter Kümmel
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012 #ifndef LOKI_FUNCTION_INC_
00013 #define LOKI_FUNCTION_INC_
00014
00015 // $Id: Function.h 750 2006-10-17 19:50:02Z syntheticpp $
00016
00017
00018 #define LOKI_ENABLE_FUNCTION
00019
00020 #include <loki/Functor.h>
00021 #include <loki/Sequence.h>
00022
00023 namespace Loki
00024 {
00025
00041
00042     template<class R = void()>
00043     struct Function;
00044
00045
00046     template<class R>
00047     struct Function<R()> : public Functor<R>
00048     {
00049         typedef Functor<R> FBase;
00050
00051         Function() : FBase() {}
00052
00053         Function(const Function& func) : FBase()
00054         {
00055             if( !func.empty())
00056                 FBase::operator=(func);
00057         }
00058
00059         // test on emptiness
00060         template<class R2>
00061         Function(Function<R2()> func) : FBase()
00062         {
00063             if(!func.empty())
00064                 FBase::operator=(func);
00065         }
00066
00067         // clear  by '= 0'
00068         Function(const int i) : FBase()
00069         {
00070             if(i==0)
00071                 FBase::clear();
00072             else
00073                 throw std::runtime_error("Loki::Function(const int i): i!=0");
00074         }
00075
00076         template<class Func>
00077         Function(Func func) : FBase(func) {}
00078
00079         template<class Host, class Func>
00080         Function(const Host& host, const Func& func) : FBase(host,func) {}
00081
00082     };
00083
00084
00086 // macros for the repetitions
00088
00089 #define LOKI_FUNCTION_BODY                          \
00090                                                     \
00091         Function() : FBase() {}                     \
00092                                                     \
00093         Function(const Function& func) : FBase()    \
00094         {                                           \
00095             if( !func.empty())                      \
00096                 FBase::operator=(func);             \
00097         }                                           \
00098                                                     \
00099         Function(const int i) : FBase()             \
00100         {                                           \
00101             if(i==0)                                \
00102                 FBase::clear();                     \
00103             else                                    \
00104                 throw std::runtime_error(           \
00105             "Loki::Function(const int i): i!=0");   \
00106         }                                           \
00107                                                     \
00108         template<class Func>                        \
00109         Function(Func func) : FBase(func) {}        \
00110                                                     \
00111         template<class Host, class Func>            \
00112         Function(const Host& host, const Func& func): FBase(host,func) {}
00113
00114
00115 #define LOKI_FUNCTION_R2_CTOR_BODY          \
00116                                             \
00117         : FBase()                           \
00118         {                                   \
00119             if(!func.empty())               \
00120                 FBase::operator=(func);     \
00121         }
00122
00123
00125 // repetitions
00127
00128     template<>
00129     struct Function<>
00130         : public Loki::Functor<>
00131     {
00132         typedef Functor<> FBase;
00133
00134         template<class R2>
00135         Function(Function<R2()> func)
00136             LOKI_FUNCTION_R2_CTOR_BODY
00137
00138         LOKI_FUNCTION_BODY // if compilation breaks here then
00139                            // Function.h was not included before
00140                            // Functor.h, check your include order
00141                            // or define LOKI_ENABLE_FUNCTION
00142     };
00143
00144     template<class R,class P01>
00145     struct Function<R(P01)>
00146         : public Loki::Functor<R, Seq<P01> >
00147     {
00148         typedef Functor<R, Seq<P01> > FBase;
00149
00150         template<class R2,class Q01>
00151         Function(Function<R2(Q01)> func)
00152             LOKI_FUNCTION_R2_CTOR_BODY
00153
00154         LOKI_FUNCTION_BODY
00155     };
00156
00157     template<class R,class P01,class P02>
00158     struct Function<R(P01,P02)>
00159         : public Functor<R, Seq<P01,P02> >
00160     {
00161         typedef Functor<R, Seq<P01,P02> > FBase;
00162
00163         template<class R2,class Q01, class Q02>
00164         Function(Function<R2(Q01,Q02)> func)
00165             LOKI_FUNCTION_R2_CTOR_BODY
00166
00167         LOKI_FUNCTION_BODY
00168     };
00169
00170     template<class R,class P01,class P02, class P03>
00171     struct Function<R(P01,P02,P03)>
00172         : public Functor<R, Seq<P01,P02,P03> >
00173     {
00174         typedef Functor<R, Seq<P01,P02,P03> > FBase;
00175
00176         template<class R2,class Q01, class Q02,class Q03>
00177         Function(Function<R2(Q01,Q02,Q03)> func)
00178             LOKI_FUNCTION_R2_CTOR_BODY
00179
00180         LOKI_FUNCTION_BODY
00181     };
00182
00183     template<class R,class P01,class P02, class P03,class P04>
00184     struct Function<R(P01,P02,P03,P04)>
00185         : public Functor<R, Seq<P01,P02,P03,P04> >
00186     {
00187         typedef Functor<R, Seq<P01,P02,P03,P04> > FBase;
00188
00189         template<class R2,class Q01,class Q02, class Q03,class Q04>
00190         Function(Function<R2(Q01,Q02,Q03,Q04)> func)
00191             LOKI_FUNCTION_R2_CTOR_BODY
00192
00193         LOKI_FUNCTION_BODY
00194     };
00195
00196     template<class R,class P01,class P02, class P03,class P04,class P05>
00197     struct Function<R(P01,P02,P03,P04,P05)>
00198         : public Functor<R, Seq<P01,P02,P03,P04,P05> >
00199     {
00200         typedef Functor<R, Seq<P01,P02,P03,P04,P05> > FBase;
00201
00202         template<class R2,class Q01,class Q02, class Q03,class Q04,class Q05>
00203         Function(Function<R2(Q01,Q02,Q03,Q04,Q05)> func)
00204             LOKI_FUNCTION_R2_CTOR_BODY
00205
00206         LOKI_FUNCTION_BODY
00207     };
00208
00209     template<class R,    class P01,class P02, class P03,class P04,class P05,
00210                         class P06>
00211     struct Function<R(P01,P02,P03,P04,P05,P06)>
00212         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06> >
00213     {
00214         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06> > FBase;
00215
00216         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00217                             class Q06>
00218         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06)> func)
00219             LOKI_FUNCTION_R2_CTOR_BODY
00220
00221         LOKI_FUNCTION_BODY
00222     };
00223
00224     template<class R,    class P01,class P02, class P03,class P04,class P05,
00225                         class P06,class P07>
00226     struct Function<R(P01,P02,P03,P04,P05,P06,P07)>
00227         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07> >
00228     {
00229         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07> > FBase;
00230
00231         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00232                             class Q06,class Q07>
00233         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07)> func)
00234             LOKI_FUNCTION_R2_CTOR_BODY
00235
00236         LOKI_FUNCTION_BODY
00237     };
00238
00239     template<class R,    class P01,class P02, class P03,class P04,class P05,
00240                         class P06,class P07, class P08>
00241     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08)>
00242         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08> >
00243     {
00244         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08> > FBase;
00245
00246         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00247                             class Q06,class Q07, class Q08>
00248         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08)> func)
00249             LOKI_FUNCTION_R2_CTOR_BODY
00250
00251         LOKI_FUNCTION_BODY
00252     };
00253
00254     template<class R,    class P01,class P02, class P03,class P04,class P05,
00255                         class P06,class P07, class P08,class P09>
00256     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09)>
00257         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09> >
00258     {
00259         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09    > > FBase;
00260
00261         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00262                             class Q06,class Q07, class Q08,class Q09>
00263         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09)> func)
00264             LOKI_FUNCTION_R2_CTOR_BODY
00265
00266         LOKI_FUNCTION_BODY
00267     };
00268
00269     template<class R,    class P01,class P02, class P03,class P04,class P05,
00270                         class P06,class P07, class P08,class P09,class P10>
00271     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10)>
00272         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10> >
00273     {
00274         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10> > FBase;
00275
00276         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00277                             class Q06,class Q07, class Q08,class Q09,class Q10>
00278         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10)> func)
00279             LOKI_FUNCTION_R2_CTOR_BODY
00280
00281         LOKI_FUNCTION_BODY
00282     };
00283
00284     template<class R,    class P01,class P02, class P03,class P04,class P05,
00285                         class P06,class P07, class P08,class P09,class P10,
00286                         class P11>
00287     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11)>
00288             : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11> >
00289     {
00290         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11> >FBase;
00291
00292         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00293                             class Q06,class Q07, class Q08,class Q09,class Q10,
00294                             class Q11>
00295         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11)> func)
00296             LOKI_FUNCTION_R2_CTOR_BODY
00297
00298         LOKI_FUNCTION_BODY
00299     };
00300
00301     template<class R,    class P01,class P02, class P03,class P04,class P05,
00302                         class P06,class P07, class P08,class P09,class P10,
00303                         class P11,class P12>
00304     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12)>
00305         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12> >
00306     {
00307         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12> > FBase;
00308
00309         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00310                             class Q06,class Q07, class Q08,class Q09,class Q10,
00311                             class Q11,class Q12>
00312         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11)> func)
00313             LOKI_FUNCTION_R2_CTOR_BODY
00314
00315         LOKI_FUNCTION_BODY
00316     };
00317
00318     template<class R,    class P01,class P02, class P03,class P04,class P05,
00319                         class P06,class P07, class P08,class P09,class P10,
00320                         class P11,class P12, class P13>
00321     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13)>
00322         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13> >
00323     {
00324         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13> > FBase;
00325
00326         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00327                             class Q06,class Q07, class Q08,class Q09,class Q10,
00328                             class Q11,class Q12, class Q13>
00329         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13)> func)
00330             LOKI_FUNCTION_R2_CTOR_BODY
00331
00332         LOKI_FUNCTION_BODY
00333     };
00334
00335     template<class R,    class P01,class P02, class P03,class P04,class P05,
00336                         class P06,class P07, class P08,class P09,class P10,
00337                         class P11,class P12, class P13,class P14>
00338     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14)>
00339         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14> >
00340     {
00341         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14> > FBase;
00342         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00343                             class Q06,class Q07, class Q08,class Q09,class Q10,
00344                             class Q11,class Q12, class Q13,class Q14>
00345         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13,Q14)> func)
00346             LOKI_FUNCTION_R2_CTOR_BODY
00347
00348         LOKI_FUNCTION_BODY
00349     };
00350
00351     template<class R,    class P01,class P02, class P03,class P04,class P05,
00352                         class P06,class P07, class P08,class P09,class P10,
00353                         class P11,class P12, class P13,class P14,class P15>
00354     struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15)>
00355         : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15> >
00356     {
00357         typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15> > FBase;
00358
00359         template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
00360                             class Q06,class Q07, class Q08,class Q09,class Q10,
00361                             class Q11,class Q12, class Q13,class Q14,class Q15>
00362         Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13,Q14,Q15)> func)
00363             LOKI_FUNCTION_R2_CTOR_BODY
00364
00365         LOKI_FUNCTION_BODY
00366     };
00367
00368 }// namespace Loki
00369
00370 #endif // end file guardian
00371
Generated on Sat Jul 7 15:11:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Functor.h Source File

Functor.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_FUNCTOR_INC_
00016 #define LOKI_FUNCTOR_INC_
00017
00018 // $Id: Functor.h 750 2006-10-17 19:50:02Z syntheticpp $
00019
00020
00021 #include "Typelist.h"
00022 #include "Sequence.h"
00023 #include "EmptyType.h"
00024 #include "SmallObj.h"
00025 #include "TypeTraits.h"
00026 #include <typeinfo>
00027 #include <memory>
00028
00030
00031 #ifndef LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
00032 //#define LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
00033 #endif
00034
00035 #ifndef LOKI_FUNCTORS_ARE_COMPARABLE
00036 //#define LOKI_FUNCTORS_ARE_COMPARABLE
00037 #endif
00038
00039
00042 namespace Loki
00043 {
00045 // class template FunctorImpl (internal)
00047
00048     namespace Private
00049     {
00050         template <typename R, template <class, class> class ThreadingModel>
00051         struct FunctorImplBase
00052 #ifdef LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
00053         {
00054 #else
00055             : public SmallValueObject<ThreadingModel>
00056         {
00057             inline FunctorImplBase() :
00058                 SmallValueObject<ThreadingModel>() {}
00059             inline FunctorImplBase(const FunctorImplBase&) :
00060                 SmallValueObject<ThreadingModel>() {}
00061 #endif
00062
00063             typedef R ResultType;
00064             typedef FunctorImplBase<R, ThreadingModel> FunctorImplBaseType;
00065
00066             typedef EmptyType Parm1;
00067             typedef EmptyType Parm2;
00068             typedef EmptyType Parm3;
00069             typedef EmptyType Parm4;
00070             typedef EmptyType Parm5;
00071             typedef EmptyType Parm6;
00072             typedef EmptyType Parm7;
00073             typedef EmptyType Parm8;
00074             typedef EmptyType Parm9;
00075             typedef EmptyType Parm10;
00076             typedef EmptyType Parm11;
00077             typedef EmptyType Parm12;
00078             typedef EmptyType Parm13;
00079             typedef EmptyType Parm14;
00080             typedef EmptyType Parm15;
00081
00082
00083             virtual ~FunctorImplBase()
00084             {}
00085
00086             virtual FunctorImplBase* DoClone() const = 0;
00087
00088             template <class U>
00089             static U* Clone(U* pObj)
00090             {
00091                 if (!pObj) return 0;
00092                 U* pClone = static_cast<U*>(pObj->DoClone());
00093                 assert(typeid(*pClone) == typeid(*pObj));
00094                 return pClone;
00095             }
00096
00097
00098 #ifdef LOKI_FUNCTORS_ARE_COMPARABLE
00099
00100             virtual bool operator==(const FunctorImplBase&) const = 0;
00101
00102 #endif
00103
00104         };
00105     }
00106
00108 // macro LOKI_DEFINE_CLONE_FUNCTORIMPL
00109 // Implements the DoClone function for a functor implementation
00111
00112 #define LOKI_DEFINE_CLONE_FUNCTORIMPL(Cls) \
00113     virtual Cls* DoClone() const { return new Cls(*this); }
00114
00116 // class template FunctorImpl
00117 // The base class for a hierarchy of functors. The FunctorImpl class is not used
00118 //     directly; rather, the Functor class manages and forwards to a pointer to
00119 //     FunctorImpl
00120 // You may want to derive your own functors from FunctorImpl.
00121 // Specializations of FunctorImpl for up to 15 parameters follow
00123
00124     template <typename R, class TList,
00125         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>
00126     class FunctorImpl;
00127
00129 // class template FunctorImpl
00130 // Specialization for 0 (zero) parameters
00132
00133     template <typename R, template <class, class> class ThreadingModel>
00134     class FunctorImpl<R, NullType, ThreadingModel>
00135         : public Private::FunctorImplBase<R, ThreadingModel>
00136     {
00137     public:
00138         typedef R ResultType;
00139         virtual R operator()() = 0;
00140     };
00141
00143 // class template FunctorImpl
00144 // Specialization for 1 parameter
00146
00147     template <typename R, typename P1, template <class, class> class ThreadingModel>
00148         class FunctorImpl<R, Seq<P1>, ThreadingModel>
00149         : public Private::FunctorImplBase<R, ThreadingModel>
00150     {
00151     public:
00152         typedef R ResultType;
00153         typedef typename TypeTraits<P1>::ParameterType Parm1;
00154         virtual R operator()(Parm1) = 0;
00155     };
00156
00158 // class template FunctorImpl
00159 // Specialization for 2 parameters
00161
00162     template <typename R, typename P1, typename P2,
00163         template <class, class> class ThreadingModel>
00164     class FunctorImpl<R, Seq<P1, P2>, ThreadingModel>
00165         : public Private::FunctorImplBase<R, ThreadingModel>
00166     {
00167     public:
00168         typedef R ResultType;
00169         typedef typename TypeTraits<P1>::ParameterType Parm1;
00170         typedef typename TypeTraits<P2>::ParameterType Parm2;
00171         virtual R operator()(Parm1, Parm2) = 0;
00172     };
00173
00175 // class template FunctorImpl
00176 // Specialization for 3 parameters
00178
00179     template <typename R, typename P1, typename P2, typename P3,
00180         template <class, class> class ThreadingModel>
00181     class FunctorImpl<R, Seq<P1, P2, P3>, ThreadingModel>
00182         : public Private::FunctorImplBase<R, ThreadingModel>
00183     {
00184     public:
00185         typedef R ResultType;
00186         typedef typename TypeTraits<P1>::ParameterType Parm1;
00187         typedef typename TypeTraits<P2>::ParameterType Parm2;
00188         typedef typename TypeTraits<P3>::ParameterType Parm3;
00189         virtual R operator()(Parm1, Parm2, Parm3) = 0;
00190     };
00191
00193 // class template FunctorImpl
00194 // Specialization for 4 parameters
00196
00197     template <typename R, typename P1, typename P2, typename P3, typename P4,
00198         template <class, class> class ThreadingModel>
00199     class FunctorImpl<R, Seq<P1, P2, P3, P4>, ThreadingModel>
00200         : public Private::FunctorImplBase<R, ThreadingModel>
00201     {
00202     public:
00203         typedef R ResultType;
00204         typedef typename TypeTraits<P1>::ParameterType Parm1;
00205         typedef typename TypeTraits<P2>::ParameterType Parm2;
00206         typedef typename TypeTraits<P3>::ParameterType Parm3;
00207         typedef typename TypeTraits<P4>::ParameterType Parm4;
00208         virtual R operator()(Parm1, Parm2, Parm3, Parm4) = 0;
00209     };
00210
00212 // class template FunctorImpl
00213 // Specialization for 5 parameters
00215
00216     template <typename R, typename P1, typename P2, typename P3, typename P4,
00217         typename P5,
00218         template <class, class> class ThreadingModel>
00219     class FunctorImpl<R, Seq<P1, P2, P3, P4, P5>, ThreadingModel>
00220         : public Private::FunctorImplBase<R, ThreadingModel>
00221     {
00222     public:
00223         typedef R ResultType;
00224         typedef typename TypeTraits<P1>::ParameterType Parm1;
00225         typedef typename TypeTraits<P2>::ParameterType Parm2;
00226         typedef typename TypeTraits<P3>::ParameterType Parm3;
00227         typedef typename TypeTraits<P4>::ParameterType Parm4;
00228         typedef typename TypeTraits<P5>::ParameterType Parm5;
00229         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5) = 0;
00230     };
00231
00233 // class template FunctorImpl
00234 // Specialization for 6 parameters
00236
00237     template <typename R, typename P1, typename P2, typename P3, typename P4,
00238         typename P5, typename P6,
00239         template <class, class> class ThreadingModel>
00240     class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6>, ThreadingModel>
00241         : public Private::FunctorImplBase<R, ThreadingModel>
00242     {
00243     public:
00244         typedef R ResultType;
00245         typedef typename TypeTraits<P1>::ParameterType Parm1;
00246         typedef typename TypeTraits<P2>::ParameterType Parm2;
00247         typedef typename TypeTraits<P3>::ParameterType Parm3;
00248         typedef typename TypeTraits<P4>::ParameterType Parm4;
00249         typedef typename TypeTraits<P5>::ParameterType Parm5;
00250         typedef typename TypeTraits<P6>::ParameterType Parm6;
00251         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6) = 0;
00252     };
00253
00255 // class template FunctorImpl
00256 // Specialization for 7 parameters
00258
00259     template <typename R, typename P1, typename P2, typename P3, typename P4,
00260         typename P5, typename P6, typename P7,
00261         template <class, class> class ThreadingModel>
00262     class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7>, ThreadingModel>
00263         : public Private::FunctorImplBase<R, ThreadingModel>
00264     {
00265     public:
00266         typedef R ResultType;
00267         typedef typename TypeTraits<P1>::ParameterType Parm1;
00268         typedef typename TypeTraits<P2>::ParameterType Parm2;
00269         typedef typename TypeTraits<P3>::ParameterType Parm3;
00270         typedef typename TypeTraits<P4>::ParameterType Parm4;
00271         typedef typename TypeTraits<P5>::ParameterType Parm5;
00272         typedef typename TypeTraits<P6>::ParameterType Parm6;
00273         typedef typename TypeTraits<P7>::ParameterType Parm7;
00274         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00275             Parm7) = 0;
00276     };
00277
00279 // class template FunctorImpl
00280 // Specialization for 8 parameters
00282
00283     template <typename R, typename P1, typename P2, typename P3, typename P4,
00284         typename P5, typename P6, typename P7, typename P8,
00285         template <class, class> class ThreadingModel>
00286     class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7, P8>,
00287             ThreadingModel>
00288         : public Private::FunctorImplBase<R, ThreadingModel>
00289     {
00290     public:
00291         typedef R ResultType;
00292         typedef typename TypeTraits<P1>::ParameterType Parm1;
00293         typedef typename TypeTraits<P2>::ParameterType Parm2;
00294         typedef typename TypeTraits<P3>::ParameterType Parm3;
00295         typedef typename TypeTraits<P4>::ParameterType Parm4;
00296         typedef typename TypeTraits<P5>::ParameterType Parm5;
00297         typedef typename TypeTraits<P6>::ParameterType Parm6;
00298         typedef typename TypeTraits<P7>::ParameterType Parm7;
00299         typedef typename TypeTraits<P8>::ParameterType Parm8;
00300         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00301             Parm7, Parm8) = 0;
00302     };
00303
00305 // class template FunctorImpl
00306 // Specialization for 9 parameters
00308
00309     template <typename R, typename P1, typename P2, typename P3, typename P4,
00310         typename P5, typename P6, typename P7, typename P8, typename P9,
00311         template <class, class> class ThreadingModel>
00312     class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9>,
00313             ThreadingModel>
00314         : public Private::FunctorImplBase<R, ThreadingModel>
00315     {
00316     public:
00317         typedef R ResultType;
00318         typedef typename TypeTraits<P1>::ParameterType Parm1;
00319         typedef typename TypeTraits<P2>::ParameterType Parm2;
00320         typedef typename TypeTraits<P3>::ParameterType Parm3;
00321         typedef typename TypeTraits<P4>::ParameterType Parm4;
00322         typedef typename TypeTraits<P5>::ParameterType Parm5;
00323         typedef typename TypeTraits<P6>::ParameterType Parm6;
00324         typedef typename TypeTraits<P7>::ParameterType Parm7;
00325         typedef typename TypeTraits<P8>::ParameterType Parm8;
00326         typedef typename TypeTraits<P9>::ParameterType Parm9;
00327         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00328             Parm7, Parm8, Parm9) = 0;
00329     };
00330
00332 // class template FunctorImpl
00333 // Specialization for 10 parameters
00335
00336     template <typename R, typename P1, typename P2, typename P3, typename P4,
00337         typename P5, typename P6, typename P7, typename P8, typename P9,
00338         typename P10,
00339         template <class, class> class ThreadingModel>
00340     class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>,
00341             ThreadingModel>
00342         : public Private::FunctorImplBase<R, ThreadingModel>
00343     {
00344     public:
00345         typedef R ResultType;
00346         typedef typename TypeTraits<P1>::ParameterType Parm1;
00347         typedef typename TypeTraits<P2>::ParameterType Parm2;
00348         typedef typename TypeTraits<P3>::ParameterType Parm3;
00349         typedef typename TypeTraits<P4>::ParameterType Parm4;
00350         typedef typename TypeTraits<P5>::ParameterType Parm5;
00351         typedef typename TypeTraits<P6>::ParameterType Parm6;
00352         typedef typename TypeTraits<P7>::ParameterType Parm7;
00353         typedef typename TypeTraits<P8>::ParameterType Parm8;
00354         typedef typename TypeTraits<P9>::ParameterType Parm9;
00355         typedef typename TypeTraits<P10>::ParameterType Parm10;
00356         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00357             Parm7, Parm8, Parm9, Parm10) = 0;
00358     };
00359
00361 // class template FunctorImpl
00362 // Specialization for 11 parameters
00364
00365     template <typename R, typename P1, typename P2, typename P3, typename P4,
00366         typename P5, typename P6, typename P7, typename P8, typename P9,
00367         typename P10, typename P11,
00368         template <class, class> class ThreadingModel>
00369     class FunctorImpl<R,
00370             Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>,
00371             ThreadingModel>
00372         : public Private::FunctorImplBase<R, ThreadingModel>
00373     {
00374     public:
00375         typedef R ResultType;
00376         typedef typename TypeTraits<P1>::ParameterType Parm1;
00377         typedef typename TypeTraits<P2>::ParameterType Parm2;
00378         typedef typename TypeTraits<P3>::ParameterType Parm3;
00379         typedef typename TypeTraits<P4>::ParameterType Parm4;
00380         typedef typename TypeTraits<P5>::ParameterType Parm5;
00381         typedef typename TypeTraits<P6>::ParameterType Parm6;
00382         typedef typename TypeTraits<P7>::ParameterType Parm7;
00383         typedef typename TypeTraits<P8>::ParameterType Parm8;
00384         typedef typename TypeTraits<P9>::ParameterType Parm9;
00385         typedef typename TypeTraits<P10>::ParameterType Parm10;
00386         typedef typename TypeTraits<P11>::ParameterType Parm11;
00387         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00388             Parm7, Parm8, Parm9, Parm10, Parm11) = 0;
00389     };
00390
00392 // class template FunctorImpl
00393 // Specialization for 12 parameters
00395
00396     template <typename R, typename P1, typename P2, typename P3, typename P4,
00397         typename P5, typename P6, typename P7, typename P8, typename P9,
00398         typename P10, typename P11, typename P12,
00399         template <class, class> class ThreadingModel>
00400     class FunctorImpl<R,
00401             Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>,
00402             ThreadingModel>
00403         : public Private::FunctorImplBase<R, ThreadingModel>
00404     {
00405     public:
00406         typedef R ResultType;
00407         typedef typename TypeTraits<P1>::ParameterType Parm1;
00408         typedef typename TypeTraits<P2>::ParameterType Parm2;
00409         typedef typename TypeTraits<P3>::ParameterType Parm3;
00410         typedef typename TypeTraits<P4>::ParameterType Parm4;
00411         typedef typename TypeTraits<P5>::ParameterType Parm5;
00412         typedef typename TypeTraits<P6>::ParameterType Parm6;
00413         typedef typename TypeTraits<P7>::ParameterType Parm7;
00414         typedef typename TypeTraits<P8>::ParameterType Parm8;
00415         typedef typename TypeTraits<P9>::ParameterType Parm9;
00416         typedef typename TypeTraits<P10>::ParameterType Parm10;
00417         typedef typename TypeTraits<P11>::ParameterType Parm11;
00418         typedef typename TypeTraits<P12>::ParameterType Parm12;
00419         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00420             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12) = 0;
00421     };
00422
00424 // class template FunctorImpl
00425 // Specialization for 13 parameters
00427
00428     template <typename R, typename P1, typename P2, typename P3, typename P4,
00429         typename P5, typename P6, typename P7, typename P8, typename P9,
00430         typename P10, typename P11, typename P12, typename P13,
00431         template <class, class> class ThreadingModel>
00432     class FunctorImpl<R,
00433             Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>,
00434             ThreadingModel>
00435         : public Private::FunctorImplBase<R, ThreadingModel>
00436     {
00437     public:
00438         typedef R ResultType;
00439         typedef typename TypeTraits<P1>::ParameterType Parm1;
00440         typedef typename TypeTraits<P2>::ParameterType Parm2;
00441         typedef typename TypeTraits<P3>::ParameterType Parm3;
00442         typedef typename TypeTraits<P4>::ParameterType Parm4;
00443         typedef typename TypeTraits<P5>::ParameterType Parm5;
00444         typedef typename TypeTraits<P6>::ParameterType Parm6;
00445         typedef typename TypeTraits<P7>::ParameterType Parm7;
00446         typedef typename TypeTraits<P8>::ParameterType Parm8;
00447         typedef typename TypeTraits<P9>::ParameterType Parm9;
00448         typedef typename TypeTraits<P10>::ParameterType Parm10;
00449         typedef typename TypeTraits<P11>::ParameterType Parm11;
00450         typedef typename TypeTraits<P12>::ParameterType Parm12;
00451         typedef typename TypeTraits<P13>::ParameterType Parm13;
00452         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00453             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13) = 0;
00454     };
00455
00457 // class template FunctorImpl
00458 // Specialization for 14 parameters
00460
00461     template <typename R, typename P1, typename P2, typename P3, typename P4,
00462         typename P5, typename P6, typename P7, typename P8, typename P9,
00463         typename P10, typename P11, typename P12, typename P13, typename P14,
00464         template <class, class> class ThreadingModel>
00465     class FunctorImpl<R,
00466             Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
00467                 P14>,
00468             ThreadingModel>
00469         : public Private::FunctorImplBase<R, ThreadingModel>
00470     {
00471     public:
00472         typedef R ResultType;
00473         typedef typename TypeTraits<P1>::ParameterType Parm1;
00474         typedef typename TypeTraits<P2>::ParameterType Parm2;
00475         typedef typename TypeTraits<P3>::ParameterType Parm3;
00476         typedef typename TypeTraits<P4>::ParameterType Parm4;
00477         typedef typename TypeTraits<P5>::ParameterType Parm5;
00478         typedef typename TypeTraits<P6>::ParameterType Parm6;
00479         typedef typename TypeTraits<P7>::ParameterType Parm7;
00480         typedef typename TypeTraits<P8>::ParameterType Parm8;
00481         typedef typename TypeTraits<P9>::ParameterType Parm9;
00482         typedef typename TypeTraits<P10>::ParameterType Parm10;
00483         typedef typename TypeTraits<P11>::ParameterType Parm11;
00484         typedef typename TypeTraits<P12>::ParameterType Parm12;
00485         typedef typename TypeTraits<P13>::ParameterType Parm13;
00486         typedef typename TypeTraits<P14>::ParameterType Parm14;
00487         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00488             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14) = 0;
00489     };
00490
00492 // class template FunctorImpl
00493 // Specialization for 15 parameters
00495
00496     template <typename R, typename P1, typename P2, typename P3, typename P4,
00497         typename P5, typename P6, typename P7, typename P8, typename P9,
00498         typename P10, typename P11, typename P12, typename P13, typename P14,
00499         typename P15, template <class, class> class ThreadingModel>
00500     class FunctorImpl<R,
00501             Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
00502                 P14, P15>,
00503             ThreadingModel>
00504         : public Private::FunctorImplBase<R, ThreadingModel>
00505     {
00506     public:
00507         typedef R ResultType;
00508         typedef typename TypeTraits<P1>::ParameterType Parm1;
00509         typedef typename TypeTraits<P2>::ParameterType Parm2;
00510         typedef typename TypeTraits<P3>::ParameterType Parm3;
00511         typedef typename TypeTraits<P4>::ParameterType Parm4;
00512         typedef typename TypeTraits<P5>::ParameterType Parm5;
00513         typedef typename TypeTraits<P6>::ParameterType Parm6;
00514         typedef typename TypeTraits<P7>::ParameterType Parm7;
00515         typedef typename TypeTraits<P8>::ParameterType Parm8;
00516         typedef typename TypeTraits<P9>::ParameterType Parm9;
00517         typedef typename TypeTraits<P10>::ParameterType Parm10;
00518         typedef typename TypeTraits<P11>::ParameterType Parm11;
00519         typedef typename TypeTraits<P12>::ParameterType Parm12;
00520         typedef typename TypeTraits<P13>::ParameterType Parm13;
00521         typedef typename TypeTraits<P14>::ParameterType Parm14;
00522         typedef typename TypeTraits<P15>::ParameterType Parm15;
00523         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00524             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14,
00525             Parm15) = 0;
00526     };
00527
00528 #ifndef LOKI_DISABLE_TYPELIST_MACROS
00529
00531 // class template FunctorImpl
00532 // Specialization for 1 parameter
00534
00535     template <typename R, typename P1, template <class, class> class ThreadingModel>
00536     class FunctorImpl<R, LOKI_TYPELIST_1(P1), ThreadingModel>
00537         : public Private::FunctorImplBase<R, ThreadingModel>
00538     {
00539     public:
00540         typedef R ResultType;
00541         typedef typename TypeTraits<P1>::ParameterType Parm1;
00542         virtual R operator()(Parm1) = 0;
00543     };
00544
00546 // class template FunctorImpl
00547 // Specialization for 2 parameters
00549
00550     template <typename R, typename P1, typename P2,
00551         template <class, class> class ThreadingModel>
00552     class FunctorImpl<R, LOKI_TYPELIST_2(P1, P2), ThreadingModel>
00553         : public Private::FunctorImplBase<R, ThreadingModel>
00554     {
00555     public:
00556         typedef R ResultType;
00557         typedef typename TypeTraits<P1>::ParameterType Parm1;
00558         typedef typename TypeTraits<P2>::ParameterType Parm2;
00559         virtual R operator()(Parm1, Parm2) = 0;
00560     };
00561
00563 // class template FunctorImpl
00564 // Specialization for 3 parameters
00566
00567     template <typename R, typename P1, typename P2, typename P3,
00568         template <class, class> class ThreadingModel>
00569     class FunctorImpl<R, LOKI_TYPELIST_3(P1, P2, P3), ThreadingModel>
00570         : public Private::FunctorImplBase<R, ThreadingModel>
00571     {
00572     public:
00573         typedef R ResultType;
00574         typedef typename TypeTraits<P1>::ParameterType Parm1;
00575         typedef typename TypeTraits<P2>::ParameterType Parm2;
00576         typedef typename TypeTraits<P3>::ParameterType Parm3;
00577         virtual R operator()(Parm1, Parm2, Parm3) = 0;
00578     };
00579
00581 // class template FunctorImpl
00582 // Specialization for 4 parameters
00584
00585     template <typename R, typename P1, typename P2, typename P3, typename P4,
00586         template <class, class> class ThreadingModel>
00587     class FunctorImpl<R, LOKI_TYPELIST_4(P1, P2, P3, P4), ThreadingModel>
00588         : public Private::FunctorImplBase<R, ThreadingModel>
00589     {
00590     public:
00591         typedef R ResultType;
00592         typedef typename TypeTraits<P1>::ParameterType Parm1;
00593         typedef typename TypeTraits<P2>::ParameterType Parm2;
00594         typedef typename TypeTraits<P3>::ParameterType Parm3;
00595         typedef typename TypeTraits<P4>::ParameterType Parm4;
00596         virtual R operator()(Parm1, Parm2, Parm3, Parm4) = 0;
00597     };
00598
00600 // class template FunctorImpl
00601 // Specialization for 5 parameters
00603
00604     template <typename R, typename P1, typename P2, typename P3, typename P4,
00605         typename P5,
00606         template <class, class> class ThreadingModel>
00607     class FunctorImpl<R, LOKI_TYPELIST_5(P1, P2, P3, P4, P5), ThreadingModel>
00608         : public Private::FunctorImplBase<R, ThreadingModel>
00609     {
00610     public:
00611         typedef R ResultType;
00612         typedef typename TypeTraits<P1>::ParameterType Parm1;
00613         typedef typename TypeTraits<P2>::ParameterType Parm2;
00614         typedef typename TypeTraits<P3>::ParameterType Parm3;
00615         typedef typename TypeTraits<P4>::ParameterType Parm4;
00616         typedef typename TypeTraits<P5>::ParameterType Parm5;
00617         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5) = 0;
00618     };
00619
00621 // class template FunctorImpl
00622 // Specialization for 6 parameters
00624
00625     template <typename R, typename P1, typename P2, typename P3, typename P4,
00626         typename P5, typename P6,
00627         template <class, class> class ThreadingModel>
00628     class FunctorImpl<R, LOKI_TYPELIST_6(P1, P2, P3, P4, P5, P6), ThreadingModel>
00629         : public Private::FunctorImplBase<R, ThreadingModel>
00630     {
00631     public:
00632         typedef R ResultType;
00633         typedef typename TypeTraits<P1>::ParameterType Parm1;
00634         typedef typename TypeTraits<P2>::ParameterType Parm2;
00635         typedef typename TypeTraits<P3>::ParameterType Parm3;
00636         typedef typename TypeTraits<P4>::ParameterType Parm4;
00637         typedef typename TypeTraits<P5>::ParameterType Parm5;
00638         typedef typename TypeTraits<P6>::ParameterType Parm6;
00639         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6) = 0;
00640     };
00641
00643 // class template FunctorImpl
00644 // Specialization for 7 parameters
00646
00647     template <typename R, typename P1, typename P2, typename P3, typename P4,
00648         typename P5, typename P6, typename P7,
00649         template <class, class> class ThreadingModel>
00650     class FunctorImpl<R, LOKI_TYPELIST_7(P1, P2, P3, P4, P5, P6, P7), ThreadingModel>
00651         : public Private::FunctorImplBase<R, ThreadingModel>
00652     {
00653     public:
00654         typedef R ResultType;
00655         typedef typename TypeTraits<P1>::ParameterType Parm1;
00656         typedef typename TypeTraits<P2>::ParameterType Parm2;
00657         typedef typename TypeTraits<P3>::ParameterType Parm3;
00658         typedef typename TypeTraits<P4>::ParameterType Parm4;
00659         typedef typename TypeTraits<P5>::ParameterType Parm5;
00660         typedef typename TypeTraits<P6>::ParameterType Parm6;
00661         typedef typename TypeTraits<P7>::ParameterType Parm7;
00662         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00663             Parm7) = 0;
00664     };
00665
00667 // class template FunctorImpl
00668 // Specialization for 8 parameters
00670
00671     template <typename R, typename P1, typename P2, typename P3, typename P4,
00672         typename P5, typename P6, typename P7, typename P8,
00673         template <class, class> class ThreadingModel>
00674     class FunctorImpl<R, LOKI_TYPELIST_8(P1, P2, P3, P4, P5, P6, P7, P8),
00675             ThreadingModel>
00676         : public Private::FunctorImplBase<R, ThreadingModel>
00677     {
00678     public:
00679         typedef R ResultType;
00680         typedef typename TypeTraits<P1>::ParameterType Parm1;
00681         typedef typename TypeTraits<P2>::ParameterType Parm2;
00682         typedef typename TypeTraits<P3>::ParameterType Parm3;
00683         typedef typename TypeTraits<P4>::ParameterType Parm4;
00684         typedef typename TypeTraits<P5>::ParameterType Parm5;
00685         typedef typename TypeTraits<P6>::ParameterType Parm6;
00686         typedef typename TypeTraits<P7>::ParameterType Parm7;
00687         typedef typename TypeTraits<P8>::ParameterType Parm8;
00688         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00689             Parm7, Parm8) = 0;
00690     };
00691
00693 // class template FunctorImpl
00694 // Specialization for 9 parameters
00696
00697     template <typename R, typename P1, typename P2, typename P3, typename P4,
00698         typename P5, typename P6, typename P7, typename P8, typename P9,
00699         template <class, class> class ThreadingModel>
00700     class FunctorImpl<R, LOKI_TYPELIST_9(P1, P2, P3, P4, P5, P6, P7, P8, P9),
00701             ThreadingModel>
00702         : public Private::FunctorImplBase<R, ThreadingModel>
00703     {
00704     public:
00705         typedef R ResultType;
00706         typedef typename TypeTraits<P1>::ParameterType Parm1;
00707         typedef typename TypeTraits<P2>::ParameterType Parm2;
00708         typedef typename TypeTraits<P3>::ParameterType Parm3;
00709         typedef typename TypeTraits<P4>::ParameterType Parm4;
00710         typedef typename TypeTraits<P5>::ParameterType Parm5;
00711         typedef typename TypeTraits<P6>::ParameterType Parm6;
00712         typedef typename TypeTraits<P7>::ParameterType Parm7;
00713         typedef typename TypeTraits<P8>::ParameterType Parm8;
00714         typedef typename TypeTraits<P9>::ParameterType Parm9;
00715         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00716             Parm7, Parm8, Parm9) = 0;
00717     };
00718
00720 // class template FunctorImpl
00721 // Specialization for 10 parameters
00723
00724     template <typename R, typename P1, typename P2, typename P3, typename P4,
00725         typename P5, typename P6, typename P7, typename P8, typename P9,
00726         typename P10,
00727         template <class, class> class ThreadingModel>
00728     class FunctorImpl<R, LOKI_TYPELIST_10(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10),
00729             ThreadingModel>
00730         : public Private::FunctorImplBase<R, ThreadingModel>
00731     {
00732     public:
00733         typedef R ResultType;
00734         typedef typename TypeTraits<P1>::ParameterType Parm1;
00735         typedef typename TypeTraits<P2>::ParameterType Parm2;
00736         typedef typename TypeTraits<P3>::ParameterType Parm3;
00737         typedef typename TypeTraits<P4>::ParameterType Parm4;
00738         typedef typename TypeTraits<P5>::ParameterType Parm5;
00739         typedef typename TypeTraits<P6>::ParameterType Parm6;
00740         typedef typename TypeTraits<P7>::ParameterType Parm7;
00741         typedef typename TypeTraits<P8>::ParameterType Parm8;
00742         typedef typename TypeTraits<P9>::ParameterType Parm9;
00743         typedef typename TypeTraits<P10>::ParameterType Parm10;
00744         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00745             Parm7, Parm8, Parm9, Parm10) = 0;
00746     };
00747
00749 // class template FunctorImpl
00750 // Specialization for 11 parameters
00752
00753     template <typename R, typename P1, typename P2, typename P3, typename P4,
00754         typename P5, typename P6, typename P7, typename P8, typename P9,
00755         typename P10, typename P11,
00756         template <class, class> class ThreadingModel>
00757     class FunctorImpl<R,
00758             LOKI_TYPELIST_11(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11),
00759             ThreadingModel>
00760         : public Private::FunctorImplBase<R, ThreadingModel>
00761     {
00762     public:
00763         typedef R ResultType;
00764         typedef typename TypeTraits<P1>::ParameterType Parm1;
00765         typedef typename TypeTraits<P2>::ParameterType Parm2;
00766         typedef typename TypeTraits<P3>::ParameterType Parm3;
00767         typedef typename TypeTraits<P4>::ParameterType Parm4;
00768         typedef typename TypeTraits<P5>::ParameterType Parm5;
00769         typedef typename TypeTraits<P6>::ParameterType Parm6;
00770         typedef typename TypeTraits<P7>::ParameterType Parm7;
00771         typedef typename TypeTraits<P8>::ParameterType Parm8;
00772         typedef typename TypeTraits<P9>::ParameterType Parm9;
00773         typedef typename TypeTraits<P10>::ParameterType Parm10;
00774         typedef typename TypeTraits<P11>::ParameterType Parm11;
00775         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00776             Parm7, Parm8, Parm9, Parm10, Parm11) = 0;
00777     };
00778
00780 // class template FunctorImpl
00781 // Specialization for 12 parameters
00783
00784     template <typename R, typename P1, typename P2, typename P3, typename P4,
00785         typename P5, typename P6, typename P7, typename P8, typename P9,
00786         typename P10, typename P11, typename P12,
00787         template <class, class> class ThreadingModel>
00788     class FunctorImpl<R,
00789             LOKI_TYPELIST_12(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12),
00790             ThreadingModel>
00791         : public Private::FunctorImplBase<R, ThreadingModel>
00792     {
00793     public:
00794         typedef R ResultType;
00795         typedef typename TypeTraits<P1>::ParameterType Parm1;
00796         typedef typename TypeTraits<P2>::ParameterType Parm2;
00797         typedef typename TypeTraits<P3>::ParameterType Parm3;
00798         typedef typename TypeTraits<P4>::ParameterType Parm4;
00799         typedef typename TypeTraits<P5>::ParameterType Parm5;
00800         typedef typename TypeTraits<P6>::ParameterType Parm6;
00801         typedef typename TypeTraits<P7>::ParameterType Parm7;
00802         typedef typename TypeTraits<P8>::ParameterType Parm8;
00803         typedef typename TypeTraits<P9>::ParameterType Parm9;
00804         typedef typename TypeTraits<P10>::ParameterType Parm10;
00805         typedef typename TypeTraits<P11>::ParameterType Parm11;
00806         typedef typename TypeTraits<P12>::ParameterType Parm12;
00807         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00808             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12) = 0;
00809     };
00810
00812 // class template FunctorImpl
00813 // Specialization for 13 parameters
00815
00816     template <typename R, typename P1, typename P2, typename P3, typename P4,
00817         typename P5, typename P6, typename P7, typename P8, typename P9,
00818         typename P10, typename P11, typename P12, typename P13,
00819         template <class, class> class ThreadingModel>
00820     class FunctorImpl<R,
00821             LOKI_TYPELIST_13(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13),
00822             ThreadingModel>
00823         : public Private::FunctorImplBase<R, ThreadingModel>
00824     {
00825     public:
00826         typedef R ResultType;
00827         typedef typename TypeTraits<P1>::ParameterType Parm1;
00828         typedef typename TypeTraits<P2>::ParameterType Parm2;
00829         typedef typename TypeTraits<P3>::ParameterType Parm3;
00830         typedef typename TypeTraits<P4>::ParameterType Parm4;
00831         typedef typename TypeTraits<P5>::ParameterType Parm5;
00832         typedef typename TypeTraits<P6>::ParameterType Parm6;
00833         typedef typename TypeTraits<P7>::ParameterType Parm7;
00834         typedef typename TypeTraits<P8>::ParameterType Parm8;
00835         typedef typename TypeTraits<P9>::ParameterType Parm9;
00836         typedef typename TypeTraits<P10>::ParameterType Parm10;
00837         typedef typename TypeTraits<P11>::ParameterType Parm11;
00838         typedef typename TypeTraits<P12>::ParameterType Parm12;
00839         typedef typename TypeTraits<P13>::ParameterType Parm13;
00840         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00841             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13) = 0;
00842     };
00843
00845 // class template FunctorImpl
00846 // Specialization for 14 parameters
00848
00849     template <typename R, typename P1, typename P2, typename P3, typename P4,
00850         typename P5, typename P6, typename P7, typename P8, typename P9,
00851         typename P10, typename P11, typename P12, typename P13, typename P14,
00852         template <class, class> class ThreadingModel>
00853     class FunctorImpl<R,
00854             LOKI_TYPELIST_14(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
00855                 P14),
00856             ThreadingModel>
00857         : public Private::FunctorImplBase<R, ThreadingModel>
00858     {
00859     public:
00860         typedef R ResultType;
00861         typedef typename TypeTraits<P1>::ParameterType Parm1;
00862         typedef typename TypeTraits<P2>::ParameterType Parm2;
00863         typedef typename TypeTraits<P3>::ParameterType Parm3;
00864         typedef typename TypeTraits<P4>::ParameterType Parm4;
00865         typedef typename TypeTraits<P5>::ParameterType Parm5;
00866         typedef typename TypeTraits<P6>::ParameterType Parm6;
00867         typedef typename TypeTraits<P7>::ParameterType Parm7;
00868         typedef typename TypeTraits<P8>::ParameterType Parm8;
00869         typedef typename TypeTraits<P9>::ParameterType Parm9;
00870         typedef typename TypeTraits<P10>::ParameterType Parm10;
00871         typedef typename TypeTraits<P11>::ParameterType Parm11;
00872         typedef typename TypeTraits<P12>::ParameterType Parm12;
00873         typedef typename TypeTraits<P13>::ParameterType Parm13;
00874         typedef typename TypeTraits<P14>::ParameterType Parm14;
00875         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00876             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14) = 0;
00877     };
00878
00880 // class template FunctorImpl
00881 // Specialization for 15 parameters
00883
00884     template <typename R, typename P1, typename P2, typename P3, typename P4,
00885         typename P5, typename P6, typename P7, typename P8, typename P9,
00886         typename P10, typename P11, typename P12, typename P13, typename P14,
00887         typename P15, template <class, class> class ThreadingModel>
00888     class FunctorImpl<R,
00889             LOKI_TYPELIST_15(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
00890                 P14, P15),
00891             ThreadingModel>
00892         : public Private::FunctorImplBase<R, ThreadingModel>
00893     {
00894     public:
00895         typedef R ResultType;
00896         typedef typename TypeTraits<P1>::ParameterType Parm1;
00897         typedef typename TypeTraits<P2>::ParameterType Parm2;
00898         typedef typename TypeTraits<P3>::ParameterType Parm3;
00899         typedef typename TypeTraits<P4>::ParameterType Parm4;
00900         typedef typename TypeTraits<P5>::ParameterType Parm5;
00901         typedef typename TypeTraits<P6>::ParameterType Parm6;
00902         typedef typename TypeTraits<P7>::ParameterType Parm7;
00903         typedef typename TypeTraits<P8>::ParameterType Parm8;
00904         typedef typename TypeTraits<P9>::ParameterType Parm9;
00905         typedef typename TypeTraits<P10>::ParameterType Parm10;
00906         typedef typename TypeTraits<P11>::ParameterType Parm11;
00907         typedef typename TypeTraits<P12>::ParameterType Parm12;
00908         typedef typename TypeTraits<P13>::ParameterType Parm13;
00909         typedef typename TypeTraits<P14>::ParameterType Parm14;
00910         typedef typename TypeTraits<P15>::ParameterType Parm15;
00911         virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
00912             Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14,
00913             Parm15) = 0;
00914     };
00915
00916 #endif //LOKI_DISABLE_TYPELIST_MACROS
00917
00919 // class template FunctorHandler
00920 // Wraps functors and pointers to functions
00922
00923     template <class ParentFunctor, typename Fun>
00924     class FunctorHandler
00925         : public ParentFunctor::Impl
00926     {
00927         typedef typename ParentFunctor::Impl Base;
00928
00929     public:
00930         typedef typename Base::ResultType ResultType;
00931         typedef typename Base::Parm1 Parm1;
00932         typedef typename Base::Parm2 Parm2;
00933         typedef typename Base::Parm3 Parm3;
00934         typedef typename Base::Parm4 Parm4;
00935         typedef typename Base::Parm5 Parm5;
00936         typedef typename Base::Parm6 Parm6;
00937         typedef typename Base::Parm7 Parm7;
00938         typedef typename Base::Parm8 Parm8;
00939         typedef typename Base::Parm9 Parm9;
00940         typedef typename Base::Parm10 Parm10;
00941         typedef typename Base::Parm11 Parm11;
00942         typedef typename Base::Parm12 Parm12;
00943         typedef typename Base::Parm13 Parm13;
00944         typedef typename Base::Parm14 Parm14;
00945         typedef typename Base::Parm15 Parm15;
00946
00947         FunctorHandler(const Fun& fun) : f_(fun) {}
00948
00949         LOKI_DEFINE_CLONE_FUNCTORIMPL(FunctorHandler)
00950
00951
00952 #ifdef LOKI_FUNCTORS_ARE_COMPARABLE
00953
00954
00955         bool operator==(const typename Base::FunctorImplBaseType& rhs) const
00956         {
00957             // there is no static information if Functor holds a member function
00958             // or a free function; this is the main difference to tr1::function
00959             if(typeid(*this) != typeid(rhs))
00960                 return false; // cannot be equal
00961
00962             const FunctorHandler& fh = static_cast<const FunctorHandler&>(rhs);
00963             // if this line gives a compiler error, you are using a function object.
00964             // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
00965             return  f_==fh.f_;
00966         }
00967 #endif
00968         // operator() implementations for up to 15 arguments
00969
00970         ResultType operator()()
00971         { return f_(); }
00972
00973         ResultType operator()(Parm1 p1)
00974         { return f_(p1); }
00975
00976         ResultType operator()(Parm1 p1, Parm2 p2)
00977         { return f_(p1, p2); }
00978
00979         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
00980         { return f_(p1, p2, p3); }
00981
00982         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
00983         { return f_(p1, p2, p3, p4); }
00984
00985         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
00986         { return f_(p1, p2, p3, p4, p5); }
00987
00988         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00989             Parm6 p6)
00990         { return f_(p1, p2, p3, p4, p5, p6); }
00991
00992         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00993             Parm6 p6, Parm7 p7)
00994         { return f_(p1, p2, p3, p4, p5, p6, p7); }
00995
00996         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
00997             Parm6 p6, Parm7 p7, Parm8 p8)
00998         { return f_(p1, p2, p3, p4, p5, p6, p7, p8); }
00999
01000         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01001             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
01002         { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
01003
01004         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01005             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
01006         { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
01007
01008         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01009             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
01010         { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
01011
01012         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01013             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01014             Parm12 p12)
01015         { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
01016
01017         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01018             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01019             Parm12 p12, Parm13 p13)
01020         { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
01021
01022         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01023             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01024             Parm12 p12, Parm13 p13, Parm14 p14)
01025         {
01026             return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
01027                 p14);
01028         }
01029
01030         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01031             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01032             Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
01033         {
01034             return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
01035                 p14, p15);
01036         }
01037
01038     private:
01039         Fun f_;
01040     };
01041
01043 // class template FunctorHandler
01044 // Wraps pointers to member functions
01046
01047     template <class ParentFunctor, typename PointerToObj,
01048         typename PointerToMemFn>
01049     class MemFunHandler : public ParentFunctor::Impl
01050     {
01051         typedef typename ParentFunctor::Impl Base;
01052
01053     public:
01054         typedef typename Base::ResultType ResultType;
01055         typedef typename Base::Parm1 Parm1;
01056         typedef typename Base::Parm2 Parm2;
01057         typedef typename Base::Parm3 Parm3;
01058         typedef typename Base::Parm4 Parm4;
01059         typedef typename Base::Parm5 Parm5;
01060         typedef typename Base::Parm6 Parm6;
01061         typedef typename Base::Parm7 Parm7;
01062         typedef typename Base::Parm8 Parm8;
01063         typedef typename Base::Parm9 Parm9;
01064         typedef typename Base::Parm10 Parm10;
01065         typedef typename Base::Parm11 Parm11;
01066         typedef typename Base::Parm12 Parm12;
01067         typedef typename Base::Parm13 Parm13;
01068         typedef typename Base::Parm14 Parm14;
01069         typedef typename Base::Parm15 Parm15;
01070
01071         MemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn)
01072         : pObj_(pObj), pMemFn_(pMemFn)
01073         {}
01074
01075         LOKI_DEFINE_CLONE_FUNCTORIMPL(MemFunHandler)
01076
01077
01078 #ifdef LOKI_FUNCTORS_ARE_COMPARABLE
01079
01080         bool operator==(const typename Base::FunctorImplBaseType& rhs) const
01081         {
01082             if(typeid(*this) != typeid(rhs))
01083                 return false; // cannot be equal
01084
01085             const MemFunHandler& mfh = static_cast<const MemFunHandler&>(rhs);
01086             // if this line gives a compiler error, you are using a function object.
01087             // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
01088             return  pObj_==mfh.pObj_ && pMemFn_==mfh.pMemFn_;
01089         }
01090 #endif
01091
01092         ResultType operator()()
01093         { return ((*pObj_).*pMemFn_)(); }
01094
01095         ResultType operator()(Parm1 p1)
01096         { return ((*pObj_).*pMemFn_)(p1); }
01097
01098         ResultType operator()(Parm1 p1, Parm2 p2)
01099         { return ((*pObj_).*pMemFn_)(p1, p2); }
01100
01101         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
01102         { return ((*pObj_).*pMemFn_)(p1, p2, p3); }
01103
01104         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
01105         { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4); }
01106
01107         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
01108         { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5); }
01109
01110         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01111             Parm6 p6)
01112         { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6); }
01113
01114         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01115             Parm6 p6, Parm7 p7)
01116         { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7); }
01117
01118         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01119             Parm6 p6, Parm7 p7, Parm8 p8)
01120         { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8); }
01121
01122         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01123             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
01124         { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
01125
01126         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01127             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
01128         { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
01129
01130         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01131             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
01132         {
01133             return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
01134                 p11);
01135         }
01136
01137         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01138             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01139             Parm12 p12)
01140         {
01141             return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
01142                 p11, p12);
01143         }
01144
01145         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01146             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01147             Parm12 p12, Parm13 p13)
01148         {
01149             return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
01150                 p11, p12, p13);
01151         }
01152
01153         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01154             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01155             Parm12 p12, Parm13 p13, Parm14 p14)
01156         {
01157             return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
01158                 p11, p12, p13, p14);
01159         }
01160
01161         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01162             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01163             Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
01164         {
01165             return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
01166                 p11, p12, p13, p14, p15);
01167         }
01168
01169     private:
01170         PointerToObj pObj_;
01171         PointerToMemFn pMemFn_;
01172     };
01173
01175 // TR1 exception
01177
01178 #ifdef LOKI_ENABLE_FUNCTION
01179
01180     class bad_function_call : public std::runtime_error
01181     {
01182     public:
01183         bad_function_call() : std::runtime_error("bad_function_call in Loki::Functor")
01184         {}
01185     };
01186
01187 #define LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL if(empty()) throw bad_function_call();
01188
01189 #else
01190
01191 #define LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01192
01193 #endif
01194
01217     template <typename R = void, class TList = NullType,
01218         template<class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>
01219     class Functor
01220     {
01221     public:
01222         // Handy type definitions for the body type
01223         typedef FunctorImpl<R, TList, ThreadingModel> Impl;
01224         typedef R ResultType;
01225         typedef TList ParmList;
01226         typedef typename Impl::Parm1 Parm1;
01227         typedef typename Impl::Parm2 Parm2;
01228         typedef typename Impl::Parm3 Parm3;
01229         typedef typename Impl::Parm4 Parm4;
01230         typedef typename Impl::Parm5 Parm5;
01231         typedef typename Impl::Parm6 Parm6;
01232         typedef typename Impl::Parm7 Parm7;
01233         typedef typename Impl::Parm8 Parm8;
01234         typedef typename Impl::Parm9 Parm9;
01235         typedef typename Impl::Parm10 Parm10;
01236         typedef typename Impl::Parm11 Parm11;
01237         typedef typename Impl::Parm12 Parm12;
01238         typedef typename Impl::Parm13 Parm13;
01239         typedef typename Impl::Parm14 Parm14;
01240         typedef typename Impl::Parm15 Parm15;
01241
01242         // Member functions
01243
01244         Functor() : spImpl_(0)
01245         {}
01246
01247         Functor(const Functor& rhs) : spImpl_(Impl::Clone(rhs.spImpl_.get()))
01248         {}
01249
01250         Functor(std::auto_ptr<Impl> spImpl) : spImpl_(spImpl)
01251         {}
01252
01253         template <typename Fun>
01254         Functor(Fun fun)
01255         : spImpl_(new FunctorHandler<Functor, Fun>(fun))
01256         {}
01257
01258         template <class PtrObj, typename MemFn>
01259         Functor(const PtrObj& p, MemFn memFn)
01260         : spImpl_(new MemFunHandler<Functor, PtrObj, MemFn>(p, memFn))
01261         {}
01262
01263         typedef Impl * (std::auto_ptr<Impl>::*unspecified_bool_type)() const;
01264
01265         operator unspecified_bool_type() const
01266         {
01267             return spImpl_.get() ? &std::auto_ptr<Impl>::get : 0;
01268         }
01269
01270         Functor& operator=(const Functor& rhs)
01271         {
01272             Functor copy(rhs);
01273             // swap auto_ptrs by hand
01274             Impl* p = spImpl_.release();
01275             spImpl_.reset(copy.spImpl_.release());
01276             copy.spImpl_.reset(p);
01277             return *this;
01278         }
01279
01280 #ifdef LOKI_ENABLE_FUNCTION
01281
01282         bool empty() const
01283         {
01284             return spImpl_.get() == 0;
01285         }
01286
01287         void clear()
01288         {
01289             spImpl_.reset(0);
01290         }
01291 #endif
01292
01293 #ifdef LOKI_FUNCTORS_ARE_COMPARABLE
01294
01295         bool operator==(const Functor& rhs) const
01296         {
01297             if(spImpl_.get()==0 && rhs.spImpl_.get()==0)
01298                 return true;
01299             if(spImpl_.get()!=0 && rhs.spImpl_.get()!=0)
01300                 return *spImpl_.get() == *rhs.spImpl_.get();
01301             else
01302                 return false;
01303         }
01304
01305         bool operator!=(const Functor& rhs) const
01306         {
01307             return !(*this==rhs);
01308         }
01309 #endif
01310
01311         // operator() implementations for up to 15 arguments
01312
01313         ResultType operator()() const
01314         {
01315             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01316             return (*spImpl_)();
01317         }
01318
01319         ResultType operator()(Parm1 p1) const
01320         {
01321             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01322             return (*spImpl_)(p1);
01323         }
01324
01325         ResultType operator()(Parm1 p1, Parm2 p2) const
01326         {
01327             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01328             return (*spImpl_)(p1, p2);
01329         }
01330
01331         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3) const
01332         {
01333             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01334             return (*spImpl_)(p1, p2, p3);
01335         }
01336
01337         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const
01338         {
01339             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01340             return (*spImpl_)(p1, p2, p3, p4);
01341         }
01342
01343         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const
01344         {
01345             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01346             return (*spImpl_)(p1, p2, p3, p4, p5);
01347         }
01348
01349         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01350             Parm6 p6) const
01351         {
01352             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01353             return (*spImpl_)(p1, p2, p3, p4, p5, p6);
01354         }
01355
01356         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01357             Parm6 p6, Parm7 p7) const
01358         {
01359             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01360             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7);
01361         }
01362
01363         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01364             Parm6 p6, Parm7 p7, Parm8 p8) const
01365         {
01366             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01367             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8);
01368         }
01369
01370         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01371             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const
01372         {
01373             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01374             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
01375         }
01376
01377         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01378             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const
01379         {
01380             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01381             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
01382         }
01383
01384         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01385             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const
01386         {
01387             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01388             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
01389         }
01390
01391         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01392             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01393             Parm12 p12) const
01394         {
01395             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01396             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
01397                 p12);
01398         }
01399
01400         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01401             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01402             Parm12 p12, Parm13 p13) const
01403         {
01404             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01405             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
01406             p12, p13);
01407         }
01408
01409         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01410             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01411             Parm12 p12, Parm13 p13, Parm14 p14) const
01412         {
01413             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01414             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
01415                 p12, p13, p14);
01416         }
01417
01418         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01419             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01420             Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const
01421         {
01422             LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
01423             return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
01424                 p12, p13, p14, p15);
01425         }
01426
01427     private:
01428         std::auto_ptr<Impl> spImpl_;
01429     };
01430
01431
01433 //
01434 //  BindersFirst and Chainer
01435 //
01437
01438     namespace Private
01439     {
01440         template <class Fctor> struct BinderFirstTraits;
01441
01442         template <typename R, class TList, template <class, class> class ThreadingModel>
01443         struct BinderFirstTraits< Functor<R, TList, ThreadingModel> >
01444         {
01445             typedef Functor<R, TList, ThreadingModel> OriginalFunctor;
01446
01447             typedef typename TL::Erase<TList,typename TL::TypeAt<TList, 0>::Result>
01448                              ::Result
01449                     ParmList;
01450
01451             typedef typename TL::TypeAt<TList, 0>::Result OriginalParm1;
01452
01453             typedef Functor<R, ParmList, ThreadingModel> BoundFunctorType;
01454
01455             typedef typename BoundFunctorType::Impl Impl;
01456
01457         };
01458
01459
01460         template<class T>
01461         struct BinderFirstBoundTypeStorage;
01462
01463         template<class T>
01464         struct BinderFirstBoundTypeStorage
01465         {
01466             typedef typename TypeTraits<T>::ParameterType RefOrValue;
01467         };
01468
01469         template <typename R, class TList, template <class, class> class ThreadingModel>
01470         struct BinderFirstBoundTypeStorage< Functor<R, TList, ThreadingModel> >
01471         {
01472             typedef Functor<R, TList, ThreadingModel> OriginalFunctor;
01473             typedef const typename TypeTraits<OriginalFunctor>::ReferredType RefOrValue;
01474         };
01475
01476
01477     } // namespace Private
01478
01485
01486     template <class OriginalFunctor>
01487     class BinderFirst
01488         : public Private::BinderFirstTraits<OriginalFunctor>::Impl
01489     {
01490         typedef typename Private::BinderFirstTraits<OriginalFunctor>::Impl Base;
01491         typedef typename OriginalFunctor::ResultType ResultType;
01492
01493         typedef typename OriginalFunctor::Parm1 BoundType;
01494
01495         typedef typename Private::BinderFirstBoundTypeStorage<
01496                              typename Private::BinderFirstTraits<OriginalFunctor>
01497                              ::OriginalParm1>
01498                          ::RefOrValue
01499                 BoundTypeStorage;
01500
01501         typedef typename OriginalFunctor::Parm2 Parm1;
01502         typedef typename OriginalFunctor::Parm3 Parm2;
01503         typedef typename OriginalFunctor::Parm4 Parm3;
01504         typedef typename OriginalFunctor::Parm5 Parm4;
01505         typedef typename OriginalFunctor::Parm6 Parm5;
01506         typedef typename OriginalFunctor::Parm7 Parm6;
01507         typedef typename OriginalFunctor::Parm8 Parm7;
01508         typedef typename OriginalFunctor::Parm9 Parm8;
01509         typedef typename OriginalFunctor::Parm10 Parm9;
01510         typedef typename OriginalFunctor::Parm11 Parm10;
01511         typedef typename OriginalFunctor::Parm12 Parm11;
01512         typedef typename OriginalFunctor::Parm13 Parm12;
01513         typedef typename OriginalFunctor::Parm14 Parm13;
01514         typedef typename OriginalFunctor::Parm15 Parm14;
01515         typedef EmptyType Parm15;
01516
01517     public:
01518
01519         BinderFirst(const OriginalFunctor& fun, BoundType bound)
01520         : f_(fun), b_(bound)
01521         {}
01522
01523         LOKI_DEFINE_CLONE_FUNCTORIMPL(BinderFirst)
01524
01525 #ifdef LOKI_FUNCTORS_ARE_COMPARABLE
01526
01527         bool operator==(const typename Base::FunctorImplBaseType& rhs) const
01528         {
01529             if(typeid(*this) != typeid(rhs))
01530                 return false; // cannot be equal
01531             // if this line gives a compiler error, you are using a function object.
01532             // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
01533             return    f_ == ((static_cast<const BinderFirst&> (rhs)).f_) &&
01534                       b_ == ((static_cast<const BinderFirst&> (rhs)).b_);
01535         }
01536 #endif
01537
01538         // operator() implementations for up to 15 arguments
01539
01540         ResultType operator()()
01541         { return f_(b_); }
01542
01543         ResultType operator()(Parm1 p1)
01544         { return f_(b_, p1); }
01545
01546         ResultType operator()(Parm1 p1, Parm2 p2)
01547         { return f_(b_, p1, p2); }
01548
01549         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
01550         { return f_(b_, p1, p2, p3); }
01551
01552         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
01553         { return f_(b_, p1, p2, p3, p4); }
01554
01555         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
01556         { return f_(b_, p1, p2, p3, p4, p5); }
01557
01558         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01559             Parm6 p6)
01560         { return f_(b_, p1, p2, p3, p4, p5, p6); }
01561
01562         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01563             Parm6 p6, Parm7 p7)
01564         { return f_(b_, p1, p2, p3, p4, p5, p6, p7); }
01565
01566         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01567             Parm6 p6, Parm7 p7, Parm8 p8)
01568         { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8); }
01569
01570         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01571             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
01572         { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9); }
01573
01574         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01575             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
01576         { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
01577
01578         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01579             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
01580         { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
01581
01582         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01583             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01584             Parm12 p12)
01585         { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
01586
01587         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01588             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01589             Parm12 p12, Parm13 p13)
01590         { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
01591
01592         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01593             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01594             Parm12 p12, Parm13 p13, Parm14 p14)
01595         {
01596             return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
01597                 p14);
01598         }
01599
01600     private:
01601         OriginalFunctor f_;
01602         BoundTypeStorage b_;
01603     };
01604
01609
01610     template <class Fctor>
01611     typename Private::BinderFirstTraits<Fctor>::BoundFunctorType
01612     BindFirst(
01613         const Fctor& fun,
01614         typename Fctor::Parm1 bound)
01615     {
01616         typedef typename Private::BinderFirstTraits<Fctor>::BoundFunctorType
01617             Outgoing;
01618
01619         return Outgoing(std::auto_ptr<typename Outgoing::Impl>(
01620             new BinderFirst<Fctor>(fun, bound)));
01621     }
01622
01629
01630     template <typename Fun1, typename Fun2>
01631     class Chainer : public Fun2::Impl
01632     {
01633         typedef Fun2 Base;
01634
01635     public:
01636         typedef typename Base::ResultType ResultType;
01637         typedef typename Base::Parm1 Parm1;
01638         typedef typename Base::Parm2 Parm2;
01639         typedef typename Base::Parm3 Parm3;
01640         typedef typename Base::Parm4 Parm4;
01641         typedef typename Base::Parm5 Parm5;
01642         typedef typename Base::Parm6 Parm6;
01643         typedef typename Base::Parm7 Parm7;
01644         typedef typename Base::Parm8 Parm8;
01645         typedef typename Base::Parm9 Parm9;
01646         typedef typename Base::Parm10 Parm10;
01647         typedef typename Base::Parm11 Parm11;
01648         typedef typename Base::Parm12 Parm12;
01649         typedef typename Base::Parm13 Parm13;
01650         typedef typename Base::Parm14 Parm14;
01651         typedef typename Base::Parm15 Parm15;
01652
01653         Chainer(const Fun1& fun1, const Fun2& fun2) : f1_(fun1), f2_(fun2) {}
01654
01655         LOKI_DEFINE_CLONE_FUNCTORIMPL(Chainer)
01656
01657 #ifdef LOKI_FUNCTORS_ARE_COMPARABLE
01658
01659         bool operator==(const typename Base::Impl::FunctorImplBaseType& rhs) const
01660         {
01661             if(typeid(*this) != typeid(rhs))
01662                 return false; // cannot be equal
01663             // if this line gives a compiler error, you are using a function object.
01664             // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
01665             return    f1_ == ((static_cast<const Chainer&> (rhs)).f2_) &&
01666                       f2_ == ((static_cast<const Chainer&> (rhs)).f1_);
01667         }
01668 #endif
01669
01670         // operator() implementations for up to 15 arguments
01671
01672         ResultType operator()()
01673         { return f1_(), f2_(); }
01674
01675         ResultType operator()(Parm1 p1)
01676         { return f1_(p1), f2_(p1); }
01677
01678         ResultType operator()(Parm1 p1, Parm2 p2)
01679         { return f1_(p1, p2), f2_(p1, p2); }
01680
01681         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
01682         { return f1_(p1, p2, p3), f2_(p1, p2, p3); }
01683
01684         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
01685         { return f1_(p1, p2, p3, p4), f2_(p1, p2, p3, p4); }
01686
01687         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
01688         { return f1_(p1, p2, p3, p4, p5), f2_(p1, p2, p3, p4, p5); }
01689
01690         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01691             Parm6 p6)
01692         { return f1_(p1, p2, p3, p4, p5, p6), f2_(p1, p2, p3, p4, p5, p6); }
01693
01694         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01695             Parm6 p6, Parm7 p7)
01696         {
01697             return f1_(p1, p2, p3, p4, p5, p6, p7),
01698                 f2_(p1, p2, p3, p4, p5, p6, p7);
01699         }
01700
01701         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01702             Parm6 p6, Parm7 p7, Parm8 p8)
01703         {
01704             return f1_(p1, p2, p3, p4, p5, p6, p7, p8),
01705                 f2_(p1, p2, p3, p4, p5, p6, p7, p8);
01706         }
01707
01708         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01709             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
01710         {
01711             return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9),
01712                 f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9);
01713         }
01714
01715         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01716             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
01717         {
01718             return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10),
01719                 f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
01720         }
01721
01722         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01723             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
01724         {
01725             return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11),
01726                 f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
01727         }
01728
01729         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01730             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01731             Parm12 p12)
01732         {
01733             return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12),
01734                 f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
01735         }
01736
01737         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01738             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01739             Parm12 p12, Parm13 p13)
01740         {
01741             return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13),
01742                 f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
01743         }
01744
01745         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01746             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01747             Parm12 p12, Parm13 p13, Parm14 p14)
01748         {
01749             return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
01750                     p14),
01751                 f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
01752                    p14);
01753         }
01754
01755         ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
01756             Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
01757             Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
01758         {
01759             return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
01760                     p14, p15),
01761                 f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
01762                     p14, p15);
01763         }
01764
01765     private:
01766         Fun1 f1_;
01767         Fun2 f2_;
01768     };
01769
01774
01775
01776     template <class Fun1, class Fun2>
01777     Fun2 Chain(
01778         const Fun1& fun1,
01779         const Fun2& fun2)
01780     {
01781         return Fun2(std::auto_ptr<typename Fun2::Impl>(
01782             new Chainer<Fun1, Fun2>(fun1, fun2)));
01783     }
01784
01785 } // namespace Loki
01786
01787
01788 #endif // end file guardian
01789
Generated on Sat Jul 7 15:11:02 2007 for Loki by doxygen 1.5.1-p1


Loki: HierarchyGenerators.h Source File

HierarchyGenerators.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_HIERARCHYGENERATORS_INC_
00016 #define LOKI_HIERARCHYGENERATORS_INC_
00017
00018 // $Id: HierarchyGenerators.h 751 2006-10-17 19:50:37Z syntheticpp $
00019
00020
00021 #include "Typelist.h"
00022 #include "TypeTraits.h"
00023 #include "EmptyType.h"
00024
00025 namespace Loki
00026 {
00027 #if defined(_MSC_VER) && _MSC_VER >= 1300
00028 #pragma warning( push )
00029  // 'class1' : base-class 'class2' is already a base-class of 'class3'
00030 #pragma warning( disable : 4584 )
00031 #endif // _MSC_VER
00032
00034 // class template GenScatterHierarchy
00035 // Generates a scattered hierarchy starting from a typelist and a template
00036 // Invocation (TList is a typelist, Unit is a template of one arg):
00037 // GenScatterHierarchy<TList, Unit>
00038 // The generated class inherits all classes generated by instantiating the
00039 // template 'Unit' with the types contained in TList
00041
00042     namespace Private
00043     {
00044         // The following type helps to overcome subtle flaw in the original
00045         // implementation of GenScatterHierarchy.
00046         // The flaw is revealed when the input type list of GenScatterHierarchy
00047         // contains more then one element of the same type (e.g. LOKI_TYPELIST_2(int, int)).
00048         // In this case GenScatterHierarchy will contain multiple bases of the same
00049         // type and some of them will not be reachable (per 10.3).
00050         // For example before the fix the first element of Tuple<LOKI_TYPELIST_2(int, int)>
00051         // is not reachable in any way!
00052         template<class, class>
00053         struct ScatterHierarchyTag;
00054     }
00055
00056     template <class TList, template <class> class Unit>
00057     class GenScatterHierarchy;
00058
00059     template <class T1, class T2, template <class> class Unit>
00060     class GenScatterHierarchy<Typelist<T1, T2>, Unit>
00061         : public GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit>
00062         , public GenScatterHierarchy<T2, Unit>
00063     {
00064     public:
00065         typedef Typelist<T1, T2> TList;
00066         // Insure that LeftBase is unique and therefore reachable
00067         typedef GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit> LeftBase;
00068         typedef GenScatterHierarchy<T2, Unit> RightBase;
00069         template <typename T> struct Rebind
00070         {
00071             typedef Unit<T> Result;
00072         };
00073     };
00074
00075     // In the middle *unique* class that resolve possible ambiguity
00076     template <class T1, class T2, template <class> class Unit>
00077     class GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit>
00078         : public GenScatterHierarchy<T1, Unit>
00079     {
00080     };
00081
00082     template <class AtomicType, template <class> class Unit>
00083     class GenScatterHierarchy : public Unit<AtomicType>
00084     {
00085         typedef Unit<AtomicType> LeftBase;
00086         template <typename T> struct Rebind
00087         {
00088             typedef Unit<T> Result;
00089         };
00090     };
00091
00092     template <template <class> class Unit>
00093     class GenScatterHierarchy<NullType, Unit>
00094     {
00095         template <typename T> struct Rebind
00096         {
00097             typedef Unit<T> Result;
00098         };
00099     };
00100
00102 // function template Field
00103 // Accesses a field in an object of a type generated with GenScatterHierarchy
00104 // Invocation (obj is an object of a type H generated with GenScatterHierarchy,
00105 //     T is a type in the typelist used to generate H):
00106 // Field<T>(obj)
00107 // returns a reference to Unit<T>, where Unit is the template used to generate H
00109
00110     template <class T, class H>
00111     typename H::template Rebind<T>::Result& Field(H& obj)
00112     {
00113         return obj;
00114     }
00115
00116     template <class T, class H>
00117     const typename H::template Rebind<T>::Result& Field(const H& obj)
00118     {
00119         return obj;
00120     }
00121
00123 // function template TupleUnit
00124 // The building block of tuples
00126
00127     template <class T>
00128     struct TupleUnit
00129     {
00130         T value_;
00131         operator T&() { return value_; }
00132         operator const T&() const { return value_; }
00133     };
00134
00136 // class template Tuple
00137 // Implements a tuple class that holds a number of values and provides field
00138 //     access to them via the Field function (below)
00140
00141     template <class TList>
00142     struct Tuple : public GenScatterHierarchy<TList, TupleUnit>
00143     {
00144     };
00145
00147 // helper class template FieldHelper
00148 // See Field below
00150
00151     template <class H, unsigned int i> struct FieldHelper;
00152
00153     template <class H>
00154     struct FieldHelper<H, 0>
00155     {
00156         typedef typename H::TList::Head ElementType;
00157         typedef typename H::template Rebind<ElementType>::Result UnitType;
00158
00159         enum
00160         {
00161             isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
00162             isConst = TypeTraits<H>::isConst
00163         };
00164
00165         typedef const typename H::LeftBase ConstLeftBase;
00166
00167         typedef typename Select<isConst, ConstLeftBase,
00168             typename H::LeftBase>::Result LeftBase;
00169
00170         typedef typename Select<isTuple, ElementType,
00171             UnitType>::Result UnqualifiedResultType;
00172
00173         typedef typename Select<isConst, const UnqualifiedResultType,
00174                         UnqualifiedResultType>::Result ResultType;
00175
00176         static ResultType& Do(H& obj)
00177         {
00178             LeftBase& leftBase = obj;
00179             return leftBase;
00180         }
00181     };
00182
00183     template <class H, unsigned int i>
00184     struct FieldHelper
00185     {
00186         typedef typename TL::TypeAt<typename H::TList, i>::Result ElementType;
00187         typedef typename H::template Rebind<ElementType>::Result UnitType;
00188
00189         enum
00190         {
00191             isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
00192             isConst = TypeTraits<H>::isConst
00193         };
00194
00195         typedef const typename H::RightBase ConstRightBase;
00196
00197         typedef typename Select<isConst, ConstRightBase,
00198             typename H::RightBase>::Result RightBase;
00199
00200         typedef typename Select<isTuple, ElementType,
00201             UnitType>::Result UnqualifiedResultType;
00202
00203         typedef typename Select<isConst, const UnqualifiedResultType,
00204                         UnqualifiedResultType>::Result ResultType;
00205
00206         static ResultType& Do(H& obj)
00207         {
00208             RightBase& rightBase = obj;
00209             return FieldHelper<RightBase, i - 1>::Do(rightBase);
00210         }
00211     };
00212
00214 // function template Field
00215 // Accesses a field in an object of a type generated with GenScatterHierarchy
00216 // Invocation (obj is an object of a type H generated with GenScatterHierarchy,
00217 //     i is the index of a type in the typelist used to generate H):
00218 // Field<i>(obj)
00219 // returns a reference to Unit<T>, where Unit is the template used to generate H
00220 //     and T is the i-th type in the typelist
00222
00223     template <int i, class H>
00224     typename FieldHelper<H, i>::ResultType&
00225     Field(H& obj)
00226     {
00227         return FieldHelper<H, i>::Do(obj);
00228     }
00229
00230 //    template <int i, class H>
00231 //    const typename FieldHelper<H, i>::ResultType&
00232 //    Field(const H& obj)
00233 //    {
00234 //        return FieldHelper<H, i>::Do(obj);
00235 //    }
00236
00238 // class template GenLinearHierarchy
00239 // Generates a linear hierarchy starting from a typelist and a template
00240 // Invocation (TList is a typelist, Unit is a template of two args):
00241 // GenScatterHierarchy<TList, Unit>
00243
00244     template
00245     <
00246         class TList,
00247         template <class AtomicType, class Base> class Unit,
00248         class Root = EmptyType
00249     >
00250     class GenLinearHierarchy;
00251
00252     template
00253     <
00254         class T1,
00255         class T2,
00256         template <class, class> class Unit,
00257         class Root
00258     >
00259     class GenLinearHierarchy<Typelist<T1, T2>, Unit, Root>
00260         : public Unit< T1, GenLinearHierarchy<T2, Unit, Root> >
00261     {
00262     };
00263
00264     template
00265     <
00266         class T,
00267         template <class, class> class Unit,
00268         class Root
00269     >
00270     class GenLinearHierarchy<Typelist<T, NullType>, Unit, Root>
00271         : public Unit<T, Root>
00272     {
00273     };
00274
00275     template
00276     <
00277         template <class, class> class Unit,
00278         class Root
00279     >
00280     class GenLinearHierarchy<NullType , Unit, Root>
00281         : public Root // is this better: Unit<NullType, Root> ?
00282     {
00283     };
00284
00285 #if defined(_MSC_VER) && _MSC_VER >= 1300
00286 #pragma warning( pop )
00287 #endif
00288 }   // namespace Loki
00289
00290 #endif // end file guardian
00291
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Key.h Source File

Key.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 by Guillaume Chatelet
00004 //
00005 // Code covered by the MIT License
00006 //
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 // purpose is hereby granted without fee, provided that the above copyright
00009 // notice appear in all copies and that both that copyright notice and this
00010 // permission notice appear in supporting documentation.
00011 //
00012 // The authors make no representations about the suitability of this software
00013 // for any purpose. It is provided "as is" without express or implied warranty.
00014 //
00015 // This code DOES NOT accompany the book:
00016 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00017 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00018 //
00020 #ifndef LOKI_KEY_INC_
00021 #define LOKI_KEY_INC_
00022
00023 // $Id: Key.h 771 2006-10-27 18:05:03Z clitte_bbt $
00024
00025
00026 #include <loki/Factory.h>
00027
00028 namespace Loki
00029 {
00030
00031      template<
00032          class Factory,
00033          typename IdentifierType
00034      >
00035      class Key;
00036
00037     template<class F, typename I>
00038     bool operator==(const Key<F, I> &k1, const Key<F, I> &k2);
00039
00040     template<class F, typename I>
00041     bool operator<(const Key<F, I> &k1, const Key<F, I> &k2);
00042
00043
00047      template<
00048          class Factory,
00049          typename IdentifierType
00050      >
00051      class Key
00052      {
00053         typedef typename Factory::Parm1 Parm1;
00054         typedef typename Factory::Parm2 Parm2;
00055         typedef typename Factory::Parm3 Parm3;
00056         typedef typename Factory::Parm4 Parm4;
00057         typedef typename Factory::Parm5 Parm5;
00058         typedef typename Factory::Parm6 Parm6;
00059         typedef typename Factory::Parm7 Parm7;
00060         typedef typename Factory::Parm8 Parm8;
00061         typedef typename Factory::Parm9 Parm9;
00062         typedef typename Factory::Parm10 Parm10;
00063         typedef typename Factory::Parm11 Parm11;
00064         typedef typename Factory::Parm12 Parm12;
00065         typedef typename Factory::Parm13 Parm13;
00066         typedef typename Factory::Parm14 Parm14;
00067         typedef typename Factory::Parm15 Parm15;
00068      public:
00069         // member variables
00070         int count; // should be const, but constness prevent default copy ctor
00071         IdentifierType id;
00072         Parm1  p1;
00073         Parm2  p2;
00074         Parm3  p3;
00075         Parm4  p4;
00076         Parm5  p5;
00077         Parm6  p6;
00078         Parm7  p7;
00079         Parm8  p8;
00080         Parm9  p9;
00081         Parm10 p10;
00082         Parm11 p11;
00083         Parm12 p12;
00084         Parm13 p13;
00085         Parm14 p14;
00086         Parm15 p15;
00087
00088         // member functions
00089         Key() : count(-1)
00090         {
00091         }
00092
00093         Key(const IdentifierType& id) : count(0)
00094         {
00095             this->id = id;
00096         }
00097
00098         Key(const IdentifierType& id,
00099                         Parm1 &p1) : count(1)
00100         {
00101             this->id = id;
00102             this->p1 = p1;
00103         }
00104
00105         Key(const IdentifierType& id,
00106                         Parm1 &p1, Parm2 &p2) : count(2)
00107         {
00108             this->id = id;
00109             this->p1 = p1;
00110             this->p2 = p2;
00111         }
00112
00113         Key(const IdentifierType& id,
00114                         Parm1 &p1, Parm2 &p2, Parm3 &p3) : count(3)
00115         {
00116             this->id = id;
00117             this->p1 = p1;
00118             this->p2 = p2;
00119             this->p3 = p3;
00120         }
00121
00122         Key(const IdentifierType& id,
00123                         Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4) : count(4)
00124         {
00125             this->id = id;
00126             this->p1 = p1;
00127             this->p2 = p2;
00128             this->p3 = p3;
00129             this->p4 = p4;
00130         }
00131
00132         Key(const IdentifierType& id,
00133                         Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5) : count(5)
00134         {
00135             this->id = id;
00136             this->p1 = p1;
00137             this->p2 = p2;
00138             this->p3 = p3;
00139             this->p4 = p4;
00140             this->p5 = p5;
00141         }
00142
00143         Key(const IdentifierType& id,
00144                         Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5,
00145                         Parm6 &p6) : count(6)
00146         {
00147             this->id = id;
00148             this->p1 = p1;
00149             this->p2 = p2;
00150             this->p3 = p3;
00151             this->p4 = p4;
00152             this->p5 = p5;
00153             this->p6 = p6;
00154         }
00155
00156         Key(const IdentifierType& id,
00157                         Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5,
00158                         Parm6 &p6, Parm7 &p7 ) : count(7)
00159         {
00160             this->id = id;
00161             this->p1 = p1;
00162             this->p2 = p2;
00163             this->p3 = p3;
00164             this->p4 = p4;
00165             this->p5 = p5;
00166             this->p6 = p6;
00167             this->p7 = p7;
00168         }
00169
00170         Key(const IdentifierType& id,
00171                         Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5,
00172                         Parm6 &p6, Parm7 &p7, Parm8 &p8) : count(8)
00173         {
00174             this->id = id;
00175             this->p1 = p1;
00176             this->p2 = p2;
00177             this->p3 = p3;
00178             this->p4 = p4;
00179             this->p5 = p5;
00180             this->p6 = p6;
00181             this->p7 = p7;
00182             this->p8 = p8;
00183         }
00184
00185         Key(const IdentifierType& id,
00186                         Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5,
00187                         Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9) : count(9)
00188         {
00189             this->id = id;
00190             this->p1 = p1;
00191             this->p2 = p2;
00192             this->p3 = p3;
00193             this->p4 = p4;
00194             this->p5 = p5;
00195             this->p6 = p6;
00196             this->p7 = p7;
00197             this->p8 = p8;
00198             this->p9 = p9;
00199         }
00200
00201         Key(const IdentifierType& id,
00202                         Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5,
00203                         Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9,Parm10 &p10) : count(10)
00204         {
00205             this->id = id;
00206             this->p1 = p1;
00207             this->p2 = p2;
00208             this->p3 = p3;
00209             this->p4 = p4;
00210             this->p5 = p5;
00211             this->p6 = p6;
00212             this->p7 = p7;
00213             this->p8 = p8;
00214             this->p9 = p9;
00215             this->p10 = p10;
00216         }
00217
00218         Key(const IdentifierType& id,
00219                         Parm1  &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5  &p5,
00220                         Parm6  &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10,
00221                         Parm11 &p11) : count(11)
00222         {
00223             this->id = id;
00224             this->p1 = p1;
00225             this->p2 = p2;
00226             this->p3 = p3;
00227             this->p4 = p4;
00228             this->p5 = p5;
00229             this->p6 = p6;
00230             this->p7 = p7;
00231             this->p8 = p8;
00232             this->p9 = p9;
00233             this->p10 = p10;
00234             this->p11 = p11;
00235         }
00236
00237         Key(const IdentifierType& id,
00238                         Parm1  &p1,  Parm2  &p2, Parm3 &p3, Parm4 &p4, Parm5  &p5,
00239                         Parm6  &p6,  Parm7  &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10,
00240                         Parm11 &p11, Parm12 &p12) : count(12)
00241         {
00242             this->id = id;
00243             this->p1 = p1;
00244             this->p2 = p2;
00245             this->p3 = p3;
00246             this->p4 = p4;
00247             this->p5 = p5;
00248             this->p6 = p6;
00249             this->p7 = p7;
00250             this->p8 = p8;
00251             this->p9 = p9;
00252             this->p10 = p10;
00253             this->p11 = p11;
00254             this->p12 = p12;
00255         }
00256
00257         Key(const IdentifierType& id,
00258                         Parm1  &p1,  Parm2  &p2,  Parm3  &p3, Parm4 &p4, Parm5  &p5,
00259                         Parm6  &p6,  Parm7  &p7,  Parm8  &p8, Parm9 &p9, Parm10 &p10,
00260                         Parm11 &p11, Parm12 &p12, Parm13 &p13) : count(13)
00261         {
00262             this->id = id;
00263             this->p1 = p1;
00264             this->p2 = p2;
00265             this->p3 = p3;
00266             this->p4 = p4;
00267             this->p5 = p5;
00268             this->p6 = p6;
00269             this->p7 = p7;
00270             this->p8 = p8;
00271             this->p9 = p9;
00272             this->p10 = p10;
00273             this->p11 = p11;
00274             this->p12 = p12;
00275             this->p13 = p13;
00276         }
00277
00278         Key(const IdentifierType& id,
00279                         Parm1  &p1,  Parm2  &p2,  Parm3  &p3,  Parm4  &p4, Parm5  &p5,
00280                         Parm6  &p6,  Parm7  &p7,  Parm8  &p8,  Parm9  &p9, Parm10 &p10,
00281                         Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14) : count(14)
00282         {
00283             this->id = id;
00284             this->p1 = p1;
00285             this->p2 = p2;
00286             this->p3 = p3;
00287             this->p4 = p4;
00288             this->p5 = p5;
00289             this->p6 = p6;
00290             this->p7 = p7;
00291             this->p8 = p8;
00292             this->p9 = p9;
00293             this->p10 = p10;
00294             this->p11 = p11;
00295             this->p12 = p12;
00296             this->p13 = p13;
00297             this->p14 = p14;
00298         }
00299
00300         Key(const IdentifierType& id,
00301                         Parm1  &p1,  Parm2  &p2,  Parm3  &p3,  Parm4  &p4,  Parm5  &p5,
00302                         Parm6  &p6,  Parm7  &p7,  Parm8  &p8,  Parm9  &p9,  Parm10 &p10,
00303                         Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14, Parm15 &p15) : count(15)
00304         {
00305             this->id = id;
00306             this->p1 = p1;
00307             this->p2 = p2;
00308             this->p3 = p3;
00309             this->p4 = p4;
00310             this->p5 = p5;
00311             this->p6 = p6;
00312             this->p7 = p7;
00313             this->p8 = p8;
00314             this->p9 = p9;
00315             this->p10 = p10;
00316             this->p11 = p11;
00317             this->p12 = p12;
00318             this->p13 = p13;
00319             this->p14 = p14;
00320             this->p15 = p15;
00321         }
00322
00323         template<class F, typename I>
00324         friend bool operator==(const Key<F, I> &k1, const Key<F, I> &k2);
00325
00326         template<class F, typename I>
00327         friend bool operator<(const Key<F, I> &k1, const Key<F, I> &k2);
00328     };
00329
00330
00331     template<class F, typename I>
00332      bool operator==(const Key<F, I> &k1, const Key<F, I> &k2)
00333     {
00334         if( k1.count != k2.count )
00335             return false;
00336         switch(k1.count){
00337             case -1:
00338                 return true;
00339             case 0:
00340                 if( k1.id == k2.id )
00341                     return true;
00342                 else
00343                     return false;
00344             case 1:
00345                 if( (k1.id == k2.id) &&
00346                     (k1.p1 == k2.p1) )
00347                     return true;
00348                 else
00349                     return false;
00350             case 2:
00351                 if( (k1.id == k2.id) &&
00352                     (k1.p1 == k2.p1) &&
00353                     (k1.p2 == k2.p2) )
00354                     return true;
00355                 else
00356                     return false;
00357             case 3:
00358                 if( (k1.id == k2.id) &&
00359                     (k1.p1 == k2.p1) &&
00360                     (k1.p2 == k2.p2) &&
00361                     (k1.p3 == k2.p3) )
00362                     return true;
00363                 else
00364                     return false;
00365             case 4:
00366                 if( (k1.id == k2.id) &&
00367                     (k1.p1 == k2.p1) &&
00368                     (k1.p2 == k2.p2) &&
00369                     (k1.p3 == k2.p3) &&
00370                     (k1.p4 == k2.p4) )
00371                     return true;
00372                 else
00373                     return false;
00374             case 5:
00375                 if( (k1.id == k2.id) &&
00376                     (k1.p1 == k2.p1) &&
00377                     (k1.p2 == k2.p2) &&
00378                     (k1.p3 == k2.p3) &&
00379                     (k1.p4 == k2.p4) &&
00380                     (k1.p5 == k2.p5) )
00381                     return true;
00382                 else
00383                     return false;
00384             case 6:
00385                 if( (k1.id == k2.id) &&
00386                     (k1.p1 == k2.p1) &&
00387                     (k1.p2 == k2.p2) &&
00388                     (k1.p3 == k2.p3) &&
00389                     (k1.p4 == k2.p4) &&
00390                     (k1.p5 == k2.p5) &&
00391                     (k1.p6 == k2.p6) )
00392                     return true;
00393                 else
00394                     return false;
00395             case 7:
00396                 if( (k1.id == k2.id) &&
00397                     (k1.p1 == k2.p1) &&
00398                     (k1.p2 == k2.p2) &&
00399                     (k1.p3 == k2.p3) &&
00400                     (k1.p4 == k2.p4) &&
00401                     (k1.p5 == k2.p5) &&
00402                     (k1.p6 == k2.p6) &&
00403                     (k1.p7 == k2.p7) )
00404                     return true;
00405                 else
00406                     return false;
00407             case 8:
00408                 if( (k1.id == k2.id) &&
00409                     (k1.p1 == k2.p1) &&
00410                     (k1.p2 == k2.p2) &&
00411                     (k1.p3 == k2.p3) &&
00412                     (k1.p4 == k2.p4) &&
00413                     (k1.p5 == k2.p5) &&
00414                     (k1.p6 == k2.p6) &&
00415                     (k1.p7 == k2.p7) &&
00416                     (k1.p8 == k2.p8) )
00417                     return true;
00418                 else
00419                     return false;
00420             case 9:
00421                 if( (k1.id == k2.id) &&
00422                     (k1.p1 == k2.p1) &&
00423                     (k1.p2 == k2.p2) &&
00424                     (k1.p3 == k2.p3) &&
00425                     (k1.p4 == k2.p4) &&
00426                     (k1.p5 == k2.p5) &&
00427                     (k1.p6 == k2.p6) &&
00428                     (k1.p7 == k2.p7) &&
00429                     (k1.p8 == k2.p8) &&
00430                     (k1.p9 == k2.p9) )
00431                     return true;
00432                 else
00433                     return false;
00434             case 10:
00435                 if( (k1.id == k2.id) &&
00436                     (k1.p1 == k2.p1) &&
00437                     (k1.p2 == k2.p2) &&
00438                     (k1.p3 == k2.p3) &&
00439                     (k1.p4 == k2.p4) &&
00440                     (k1.p5 == k2.p5) &&
00441                     (k1.p6 == k2.p6) &&
00442                     (k1.p7 == k2.p7) &&
00443                     (k1.p8 == k2.p8) &&
00444                     (k1.p9 == k2.p9) &&
00445                     (k1.p10 == k2.p10) )
00446                     return true;
00447                 else
00448                     return false;
00449             case 11:
00450                 if( (k1.id == k2.id) &&
00451                     (k1.p1 == k2.p1) &&
00452                     (k1.p2 == k2.p2) &&
00453                     (k1.p3 == k2.p3) &&
00454                     (k1.p4 == k2.p4) &&
00455                     (k1.p5 == k2.p5) &&
00456                     (k1.p6 == k2.p6) &&
00457                     (k1.p7 == k2.p7) &&
00458                     (k1.p8 == k2.p8) &&
00459                     (k1.p9 == k2.p9) &&
00460                     (k1.p10 == k2.p10) &&
00461                     (k1.p11 == k2.p11) )
00462                     return true;
00463                 else
00464                     return false;
00465             case 12:
00466                 if( (k1.id == k2.id) &&
00467                     (k1.p1 == k2.p1) &&
00468                     (k1.p2 == k2.p2) &&
00469                     (k1.p3 == k2.p3) &&
00470                     (k1.p4 == k2.p4) &&
00471                     (k1.p5 == k2.p5) &&
00472                     (k1.p6 == k2.p6) &&
00473                     (k1.p7 == k2.p7) &&
00474                     (k1.p8 == k2.p8) &&
00475                     (k1.p9 == k2.p9) &&
00476                     (k1.p10 == k2.p10) &&
00477                     (k1.p11 == k2.p11) &&
00478                     (k1.p12 == k2.p12) )
00479                     return true;
00480                 else
00481                     return false;
00482             case 13:
00483                 if( (k1.id == k2.id) &&
00484                     (k1.p1 == k2.p1) &&
00485                     (k1.p2 == k2.p2) &&
00486                     (k1.p3 == k2.p3) &&
00487                     (k1.p4 == k2.p4) &&
00488                     (k1.p5 == k2.p5) &&
00489                     (k1.p6 == k2.p6) &&
00490                     (k1.p7 == k2.p7) &&
00491                     (k1.p8 == k2.p8) &&
00492                     (k1.p9 == k2.p9) &&
00493                     (k1.p10 == k2.p10) &&
00494                     (k1.p11 == k2.p11) &&
00495                     (k1.p12 == k2.p12) &&
00496                     (k1.p13 == k2.p13) )
00497                     return true;
00498                 else
00499                     return false;
00500             case 14:
00501                 if( (k1.id == k2.id) &&
00502                     (k1.p1 == k2.p1) &&
00503                     (k1.p2 == k2.p2) &&
00504                     (k1.p3 == k2.p3) &&
00505                     (k1.p4 == k2.p4) &&
00506                     (k1.p5 == k2.p5) &&
00507                     (k1.p6 == k2.p6) &&
00508                     (k1.p7 == k2.p7) &&
00509                     (k1.p8 == k2.p8) &&
00510                     (k1.p9 == k2.p9) &&
00511                     (k1.p10 == k2.p10) &&
00512                     (k1.p11 == k2.p11) &&
00513                     (k1.p12 == k2.p12) &&
00514                     (k1.p13 == k2.p13) &&
00515                     (k1.p14 == k2.p14) )
00516                     return true;
00517                 else
00518                     return false;
00519             case 15:
00520                 if( (k1.id == k2.id) &&
00521                     (k1.p1 == k2.p1) &&
00522                     (k1.p2 == k2.p2) &&
00523                     (k1.p3 == k2.p3) &&
00524                     (k1.p4 == k2.p4) &&
00525                     (k1.p5 == k2.p5) &&
00526                     (k1.p6 == k2.p6) &&
00527                     (k1.p7 == k2.p7) &&
00528                     (k1.p8 == k2.p8) &&
00529                     (k1.p9 == k2.p9) &&
00530                     (k1.p10 == k2.p10) &&
00531                     (k1.p11 == k2.p11) &&
00532                     (k1.p12 == k2.p12) &&
00533                     (k1.p13 == k2.p13) &&
00534                     (k1.p14 == k2.p14) &&
00535                     (k1.p15 == k2.p15) )
00536                     return true;
00537                 else
00538                     return false;
00539             default:
00540                 return false;
00541         }
00542     }
00543
00544
00545
00546     template<class F, typename I>
00547     bool operator<(const Key<F, I> &k1, const Key<F, I> &k2)
00548     {
00549         if( k1.count < k2.count )
00550             return true;
00551         switch(k1.count){
00552             case -1:
00553                 return false;
00554             case 0:
00555                 if( k1.id < k2.id )
00556                     return true;
00557                 else
00558                     return false;
00559             case 1:
00560                 if( (k1.id < k2.id) ||
00561                     (k1.p1 < k2.p1) )
00562                     return true;
00563                 else
00564                     return false;
00565             case 2:
00566                 if( (k1.id < k2.id) ||
00567                     (k1.p1 < k2.p1) ||
00568                     (k1.p2 < k2.p2) )
00569                     return true;
00570                 else
00571                     return false;
00572             case 3:
00573                 if( (k1.id < k2.id) ||
00574                     (k1.p1 < k2.p1) ||
00575                     (k1.p2 < k2.p2) ||
00576                     (k1.p3 < k2.p3) )
00577                     return true;
00578                 else
00579                     return false;
00580             case 4:
00581                 if( (k1.id < k2.id) ||
00582                     (k1.p1 < k2.p1) ||
00583                     (k1.p2 < k2.p2) ||
00584                     (k1.p3 < k2.p3) ||
00585                     (k1.p4 < k2.p4) )
00586                     return true;
00587                 else
00588                     return false;
00589             case 5:
00590                 if( (k1.id < k2.id) ||
00591                     (k1.p1 < k2.p1) ||
00592                     (k1.p2 < k2.p2) ||
00593                     (k1.p3 < k2.p3) ||
00594                     (k1.p4 < k2.p4) ||
00595                     (k1.p5 < k2.p5) )
00596                     return true;
00597                 else
00598                     return false;
00599             case 6:
00600                 if( (k1.id < k2.id) ||
00601                     (k1.p1 < k2.p1) ||
00602                     (k1.p2 < k2.p2) ||
00603                     (k1.p3 < k2.p3) ||
00604                     (k1.p4 < k2.p4) ||
00605                     (k1.p5 < k2.p5) ||
00606                     (k1.p6 < k2.p6) )
00607                     return true;
00608                 else
00609                     return false;
00610             case 7:
00611                 if( (k1.id < k2.id) ||
00612                     (k1.p1 < k2.p1) ||
00613                     (k1.p2 < k2.p2) ||
00614                     (k1.p3 < k2.p3) ||
00615                     (k1.p4 < k2.p4) ||
00616                     (k1.p5 < k2.p5) ||
00617                     (k1.p6 < k2.p6) ||
00618                     (k1.p7 < k2.p7) )
00619                     return true;
00620                 else
00621                     return false;
00622             case 8:
00623                 if( (k1.id < k2.id) ||
00624                     (k1.p1 < k2.p1) ||
00625                     (k1.p2 < k2.p2) ||
00626                     (k1.p3 < k2.p3) ||
00627                     (k1.p4 < k2.p4) ||
00628                     (k1.p5 < k2.p5) ||
00629                     (k1.p6 < k2.p6) ||
00630                     (k1.p7 < k2.p7) ||
00631                     (k1.p8 < k2.p8) )
00632                     return true;
00633                 else
00634                     return false;
00635             case 9:
00636                 if( (k1.id < k2.id) ||
00637                     (k1.p1 < k2.p1) ||
00638                     (k1.p2 < k2.p2) ||
00639                     (k1.p3 < k2.p3) ||
00640                     (k1.p4 < k2.p4) ||
00641                     (k1.p5 < k2.p5) ||
00642                     (k1.p6 < k2.p6) ||
00643                     (k1.p7 < k2.p7) ||
00644                     (k1.p8 < k2.p8) ||
00645                     (k1.p9 < k2.p9) )
00646                     return true;
00647                 else
00648                     return false;
00649             case 10:
00650                 if( (k1.id < k2.id) ||
00651                     (k1.p1 < k2.p1) ||
00652                     (k1.p2 < k2.p2) ||
00653                     (k1.p3 < k2.p3) ||
00654                     (k1.p4 < k2.p4) ||
00655                     (k1.p5 < k2.p5) ||
00656                     (k1.p6 < k2.p6) ||
00657                     (k1.p7 < k2.p7) ||
00658                     (k1.p8 < k2.p8) ||
00659                     (k1.p9 < k2.p9) ||
00660                     (k1.p10 < k2.p10) )
00661                     return true;
00662                 else
00663                     return false;
00664             case 11:
00665                 if( (k1.id < k2.id) ||
00666                     (k1.p1 < k2.p1) ||
00667                     (k1.p2 < k2.p2) ||
00668                     (k1.p3 < k2.p3) ||
00669                     (k1.p4 < k2.p4) ||
00670                     (k1.p5 < k2.p5) ||
00671                     (k1.p6 < k2.p6) ||
00672                     (k1.p7 < k2.p7) ||
00673                     (k1.p8 < k2.p8) ||
00674                     (k1.p9 < k2.p9) ||
00675                     (k1.p10 < k2.p10) ||
00676                     (k1.p11 < k2.p11) )
00677                     return true;
00678                 else
00679                     return false;
00680             case 12:
00681                 if( (k1.id < k2.id) ||
00682                     (k1.p1 < k2.p1) ||
00683                     (k1.p2 < k2.p2) ||
00684                     (k1.p3 < k2.p3) ||
00685                     (k1.p4 < k2.p4) ||
00686                     (k1.p5 < k2.p5) ||
00687                     (k1.p6 < k2.p6) ||
00688                     (k1.p7 < k2.p7) ||
00689                     (k1.p8 < k2.p8) ||
00690                     (k1.p9 < k2.p9) ||
00691                     (k1.p10 < k2.p10) ||
00692                     (k1.p11 < k2.p11) ||
00693                     (k1.p12 < k2.p12) )
00694                     return true;
00695                 else
00696                     return false;
00697             case 13:
00698                 if( (k1.id < k2.id) ||
00699                     (k1.p1 < k2.p1) ||
00700                     (k1.p2 < k2.p2) ||
00701                     (k1.p3 < k2.p3) ||
00702                     (k1.p4 < k2.p4) ||
00703                     (k1.p5 < k2.p5) ||
00704                     (k1.p6 < k2.p6) ||
00705                     (k1.p7 < k2.p7) ||
00706                     (k1.p8 < k2.p8) ||
00707                     (k1.p9 < k2.p9) ||
00708                     (k1.p10 < k2.p10) ||
00709                     (k1.p11 < k2.p11) ||
00710                     (k1.p12 < k2.p12) ||
00711                     (k1.p13 < k2.p13) )
00712                     return true;
00713                 else
00714                     return false;
00715             case 14:
00716                 if( (k1.id < k2.id) ||
00717                     (k1.p1 < k2.p1) ||
00718                     (k1.p2 < k2.p2) ||
00719                     (k1.p3 < k2.p3) ||
00720                     (k1.p4 < k2.p4) ||
00721                     (k1.p5 < k2.p5) ||
00722                     (k1.p6 < k2.p6) ||
00723                     (k1.p7 < k2.p7) ||
00724                     (k1.p8 < k2.p8) ||
00725                     (k1.p9 < k2.p9) ||
00726                     (k1.p10 < k2.p10) ||
00727                     (k1.p11 < k2.p11) ||
00728                     (k1.p12 < k2.p12) ||
00729                     (k1.p13 < k2.p13) ||
00730                     (k1.p14 < k2.p14) )
00731                     return true;
00732                 else
00733                     return false;
00734             case 15:
00735                 if( (k1.id < k2.id) ||
00736                     (k1.p1 < k2.p1) ||
00737                     (k1.p2 < k2.p2) ||
00738                     (k1.p3 < k2.p3) ||
00739                     (k1.p4 < k2.p4) ||
00740                     (k1.p5 < k2.p5) ||
00741                     (k1.p6 < k2.p6) ||
00742                     (k1.p7 < k2.p7) ||
00743                     (k1.p8 < k2.p8) ||
00744                     (k1.p9 < k2.p9) ||
00745                     (k1.p10 < k2.p10) ||
00746                     (k1.p11 < k2.p11) ||
00747                     (k1.p12 < k2.p12) ||
00748                     (k1.p13 < k2.p13) ||
00749                     (k1.p14 < k2.p14) ||
00750                     (k1.p15 < k2.p15) )
00751                     return true;
00752                 else
00753                     return false;
00754             default:
00755                 return false;
00756         }
00757     }
00758
00759
00760
00761 } // namespace Loki
00762
00763 #endif // end file guardian
00764
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: LockingPtr.h Source File

LockingPtr.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code is from the article:
00005 //     "Generic<Programming>: volatile — Multithreaded Programmer’s Best Friend
00006 //     Volatile-Correctness or How to Have Your Compiler Detect Race Conditions
00007 //     for You" by Alexandrescu, Andrei.
00008 //     Published in the February 2001 issue of the C/C++ Users Journal.
00009 //     http://www.cuj.com/documents/s=7998/cujcexp1902alexandr/
00010 // Prepared for Loki library by Richard Sposato
00012 #ifndef LOKI_LOCKING_PTR_INC_
00013 #define LOKI_LOCKING_PTR_INC_
00014
00015 // $Id: LockingPtr.h 748 2006-10-17 19:49:08Z syntheticpp $
00016
00017
00018 #include <loki/ConstPolicy.h>
00019
00020 namespace Loki
00021 {
00030     template < typename SharedObject, typename LockingPolicy = LOKI_DEFAULT_MUTEX,
00031                template<class> class ConstPolicy = LOKI_DEFAULT_CONSTNESS >
00032     class LockingPtr
00033     {
00034     public:
00035
00036         typedef typename ConstPolicy<SharedObject>::Type ConstOrNotType;
00037
00042         LockingPtr( volatile ConstOrNotType & object, LockingPolicy & mutex )
00043            : pObject_( const_cast< SharedObject * >( &object ) ),
00044             pMutex_( &mutex )
00045         {
00046             mutex.Lock();
00047         }
00048
00049         typedef typename std::pair<volatile ConstOrNotType *, LockingPolicy *> Pair;
00050
00054         LockingPtr( Pair lockpair )
00055            : pObject_( const_cast< SharedObject * >( lockpair.first ) ),
00056             pMutex_( lockpair.second )
00057         {
00058             lockpair.second->Lock();
00059         }
00060
00062         ~LockingPtr()
00063         {
00064             pMutex_->Unlock();
00065         }
00066
00068         ConstOrNotType & operator * ()
00069         {
00070             return *pObject_;
00071         }
00072
00074         ConstOrNotType * operator -> ()
00075         {
00076             return pObject_;
00077         }
00078
00079     private:
00080
00082         LockingPtr();
00083
00085         LockingPtr( const LockingPtr & );
00086
00088         LockingPtr & operator = ( const LockingPtr & );
00089
00091         ConstOrNotType * pObject_;
00092
00094         LockingPolicy * pMutex_;
00095
00096     }; // end class LockingPtr
00097
00098 } // namespace Loki
00099
00100 #endif // end file guardian
00101
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: LokiExport.h Source File

LokiExport.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 by Peter Kümmel
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012 #ifndef LOKI_LOKIEXPORT_INC_
00013 #define LOKI_LOKIEXPORT_INC_
00014
00015 // $Id: LokiExport.h 748 2006-10-17 19:49:08Z syntheticpp $
00016
00017
00018 #ifdef __GNUC__
00019
00020 #ifdef _HAVE_GCC_VISIBILITY
00021 #define LOKI_EXPORT_SPEC __attribute__ ((visibility("default")))
00022 #define LOKI_IMPORT_SPEC
00023 #else
00024 #define LOKI_EXPORT_SPEC
00025 #define LOKI_IMPORT_SPEC
00026 #endif
00027
00028 #else
00029
00030 #ifdef _WIN32
00031 #define LOKI_EXPORT_SPEC __declspec(dllexport)
00032 #define LOKI_IMPORT_SPEC __declspec(dllimport)
00033 #else
00034 #define LOKI_EXPORT_SPEC
00035 #define LOKI_IMPORT_SPEC
00036 #endif
00037
00038 #endif
00039
00040
00041 #if (defined(LOKI_MAKE_DLL) && defined(LOKI_DLL)) || \
00042     (defined(LOKI_MAKE_DLL) && defined(LOKI_STATIC)) || \
00043     (defined(LOKI_DLL) && defined(LOKI_STATIC))
00044 #error export macro error: you could not build AND use the library
00045 #endif
00046
00047 #ifdef LOKI_MAKE_DLL
00048 #define LOKI_EXPORT LOKI_EXPORT_SPEC
00049 #endif
00050
00051 #ifdef LOKI_DLL
00052 #define LOKI_EXPORT LOKI_IMPORT_SPEC
00053 #endif
00054
00055 #ifdef LOKI_STATIC
00056 #define LOKI_EXPORT
00057 #endif
00058
00059 #if !defined(LOKI_EXPORT) && !defined(EXPLICIT_EXPORT)
00060 #define LOKI_EXPORT
00061 #endif
00062
00063 #ifndef LOKI_EXPORT
00064 #error export macro error: LOKI_EXPORT was not defined, disable EXPLICIT_EXPORT or define a export specification
00065 #endif
00066
00067
00068 #endif // end file guardian
00069
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: LokiTypeInfo.h Source File

LokiTypeInfo.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_LOKITYPEINFO_INC_
00016 #define LOKI_LOKITYPEINFO_INC_
00017
00018 // $Id: LokiTypeInfo.h 748 2006-10-17 19:49:08Z syntheticpp $
00019
00020
00021 #include <typeinfo>
00022 #include <cassert>
00023 #include "Typelist.h"
00024
00025 namespace Loki
00026 {
00028 // class TypeInfo
00029 // Purpose: offer a first-class, comparable wrapper over std::type_info
00031
00032     class TypeInfo
00033     {
00034     public:
00035         // Constructors
00036         TypeInfo(); // needed for containers
00037         TypeInfo(const std::type_info&); // non-explicit
00038
00039         // Access for the wrapped std::type_info
00040         const std::type_info& Get() const;
00041         // Compatibility functions
00042         bool before(const TypeInfo& rhs) const;
00043         const char* name() const;
00044
00045     private:
00046         const std::type_info* pInfo_;
00047     };
00048
00049 // Implementation
00050
00051     inline TypeInfo::TypeInfo()
00052     {
00053         class Nil {};
00054         pInfo_ = &typeid(Nil);
00055         assert(pInfo_);
00056     }
00057
00058     inline TypeInfo::TypeInfo(const std::type_info& ti)
00059     : pInfo_(&ti)
00060     { assert(pInfo_); }
00061
00062     inline bool TypeInfo::before(const TypeInfo& rhs) const
00063     {
00064         assert(pInfo_);
00065         // type_info::before return type is int in some VC libraries
00066         return pInfo_->before(*rhs.pInfo_) != 0;
00067     }
00068
00069     inline const std::type_info& TypeInfo::Get() const
00070     {
00071         assert(pInfo_);
00072         return *pInfo_;
00073     }
00074
00075     inline const char* TypeInfo::name() const
00076     {
00077         assert(pInfo_);
00078         return pInfo_->name();
00079     }
00080
00081 // Comparison operators
00082
00083     inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
00084     // type_info::operator== return type is int in some VC libraries
00085     { return (lhs.Get() == rhs.Get()) != 0; }
00086
00087     inline bool operator<(const TypeInfo& lhs, const TypeInfo& rhs)
00088     { return lhs.before(rhs); }
00089
00090     inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
00091     { return !(lhs == rhs); }
00092
00093     inline bool operator>(const TypeInfo& lhs, const TypeInfo& rhs)
00094     { return rhs < lhs; }
00095
00096     inline bool operator<=(const TypeInfo& lhs, const TypeInfo& rhs)
00097     { return !(lhs > rhs); }
00098
00099     inline bool operator>=(const TypeInfo& lhs, const TypeInfo& rhs)
00100     { return !(lhs < rhs); }
00101 }
00102
00103 #endif // end file guardian
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: MultiMethods.h Source File

MultiMethods.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_MULTIMETHODS_INC_
00016 #define LOKI_MULTIMETHODS_INC_
00017
00018 // $Id: MultiMethods.h 751 2006-10-17 19:50:37Z syntheticpp $
00019
00020
00021 #include "Typelist.h"
00022 #include "LokiTypeInfo.h"
00023 #include "Functor.h"
00024 #include "AssocVector.h"
00025
00027 // IMPORTANT NOTE:
00028 // The double dispatchers implemented below differ from the excerpts shown in
00029 // the book - they are simpler while respecting the same interface.
00031
00032 namespace Loki
00033 {
00035 // class template InvocationTraits (helper)
00036 // Helps implementing optional symmetry
00038
00039     namespace Private
00040     {
00041         template <class SomeLhs, class SomeRhs,
00042             class Executor, typename ResultType>
00043         struct InvocationTraits
00044         {
00045             static ResultType
00046         DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
00047             Executor& exec, Int2Type<false>)
00048             {
00049                 return exec.Fire(lhs, rhs);
00050             }
00051             static ResultType
00052         DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
00053             Executor& exec, Int2Type<true>)
00054             {
00055                 return exec.Fire(rhs, lhs);
00056             }
00057         };
00058     }
00059
00061 // class template StaticDispatcher
00062 // Implements an automatic static double dispatcher based on two typelists
00064
00065     template
00066     <
00067         class Executor,
00068         class BaseLhs,
00069         class TypesLhs,
00070         bool symmetric = true,
00071         class BaseRhs = BaseLhs,
00072         class TypesRhs = TypesLhs,
00073         typename ResultType = void
00074     >
00075     class StaticDispatcher
00076     {
00077         template <class SomeLhs>
00078         static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
00079             Executor exec, NullType)
00080         { return exec.OnError(lhs, rhs); }
00081
00082         template <class Head, class Tail, class SomeLhs>
00083         static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
00084             Executor exec, Typelist<Head, Tail>)
00085         {
00086             if (Head* p2 = dynamic_cast<Head*>(&rhs))
00087             {
00088                 Int2Type<(symmetric &&
00089                           int(TL::IndexOf<TypesRhs, Head>::value) <
00090                           int(TL::IndexOf<TypesLhs, SomeLhs>::value))> i2t;
00091
00092                 typedef Private::InvocationTraits<
00093                         SomeLhs, Head, Executor, ResultType> CallTraits;
00094
00095                 return CallTraits::DoDispatch(lhs, *p2, exec, i2t);
00096             }
00097             return DispatchRhs(lhs, rhs, exec, Tail());
00098         }
00099
00100         static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs,
00101             Executor exec, NullType)
00102         { return exec.OnError(lhs, rhs); }
00103
00104         template <class Head, class Tail>
00105         static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs,
00106             Executor exec, Typelist<Head, Tail>)
00107         {
00108             if (Head* p1 = dynamic_cast<Head*>(&lhs))
00109             {
00110                 return DispatchRhs(*p1, rhs, exec, TypesRhs());
00111             }
00112             return DispatchLhs(lhs, rhs, exec, Tail());
00113         }
00114
00115     public:
00116         static ResultType Go(BaseLhs& lhs, BaseRhs& rhs,
00117             Executor exec)
00118         { return DispatchLhs(lhs, rhs, exec, TypesLhs()); }
00119     };
00120
00122 // class template BasicDispatcher
00123 // Implements a logarithmic double dispatcher for functors (or functions)
00124 // Doesn't offer automated casts or symmetry
00126
00127     template
00128     <
00129         class BaseLhs,
00130         class BaseRhs = BaseLhs,
00131         typename ResultType = void,
00132         typename CallbackType = ResultType (*)(BaseLhs&, BaseRhs&)
00133     >
00134     class BasicDispatcher
00135     {
00136         typedef std::pair<TypeInfo,TypeInfo> KeyType;
00137         typedef CallbackType MappedType;
00138         typedef AssocVector<KeyType, MappedType> MapType;
00139         MapType callbackMap_;
00140
00141         void DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun);
00142         bool DoRemove(TypeInfo lhs, TypeInfo rhs);
00143
00144     public:
00145         template <class SomeLhs, class SomeRhs>
00146         void Add(CallbackType fun)
00147         {
00148             DoAdd(typeid(SomeLhs), typeid(SomeRhs), fun);
00149         }
00150
00151         template <class SomeLhs, class SomeRhs>
00152         bool Remove()
00153         {
00154             return DoRemove(typeid(SomeLhs), typeid(SomeRhs));
00155         }
00156
00157         ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
00158     };
00159
00160     // Non-inline to reduce compile time overhead...
00161     template <class BaseLhs, class BaseRhs,
00162         typename ResultType, typename CallbackType>
00163     void BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType>
00164          ::DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun)
00165     {
00166         callbackMap_[KeyType(lhs, rhs)] = fun;
00167     }
00168
00169     template <class BaseLhs, class BaseRhs,
00170         typename ResultType, typename CallbackType>
00171     bool BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType>
00172          ::DoRemove(TypeInfo lhs, TypeInfo rhs)
00173     {
00174         return callbackMap_.erase(KeyType(lhs, rhs)) == 1;
00175     }
00176
00177     template <class BaseLhs, class BaseRhs,
00178         typename ResultType, typename CallbackType>
00179     ResultType BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType>
00180                ::Go(BaseLhs& lhs, BaseRhs& rhs)
00181     {
00182         typename MapType::key_type k(typeid(lhs),typeid(rhs));
00183         typename MapType::iterator i = callbackMap_.find(k);
00184         if (i == callbackMap_.end())
00185         {
00186                 throw std::runtime_error("Function not found");
00187         }
00188         return (i->second)(lhs, rhs);
00189     }
00190
00192 // class template StaticCaster
00193 // Implementation of the CastingPolicy used by FunctorDispatcher
00195
00196     template <class To, class From>
00197     struct StaticCaster
00198     {
00199         static To& Cast(From& obj)
00200         {
00201             return static_cast<To&>(obj);
00202         }
00203     };
00204
00206 // class template DynamicCaster
00207 // Implementation of the CastingPolicy used by FunctorDispatcher
00209
00210     template <class To, class From>
00211     struct DynamicCaster
00212     {
00213         static To& Cast(From& obj)
00214         {
00215             return dynamic_cast<To&>(obj);
00216         }
00217     };
00218
00220 // class template Private::FnDispatcherHelper
00221 // Implements trampolines and argument swapping used by FnDispatcher
00223
00224     namespace Private
00225     {
00226         template <class BaseLhs, class BaseRhs,
00227         class SomeLhs, class SomeRhs,
00228             typename ResultType,
00229             class CastLhs, class CastRhs,
00230             ResultType (*Callback)(SomeLhs&, SomeRhs&)>
00231         struct FnDispatcherHelper
00232         {
00233             static ResultType Trampoline(BaseLhs& lhs, BaseRhs& rhs)
00234             {
00235                 return Callback(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
00236             }
00237             static ResultType TrampolineR(BaseRhs& rhs, BaseLhs& lhs)
00238             {
00239                 return Trampoline(lhs, rhs);
00240             }
00241         };
00242     }
00243
00245 // class template FnDispatcher
00246 // Implements an automatic logarithmic double dispatcher for functions
00247 // Features automated conversions
00249
00250     template <class BaseLhs, class BaseRhs = BaseLhs,
00251               typename ResultType = void,
00252               template <class, class> class CastingPolicy = DynamicCaster,
00253               template <class, class, class, class>
00254               class DispatcherBackend = BasicDispatcher>
00255     class FnDispatcher
00256     {
00257         DispatcherBackend<BaseLhs, BaseRhs, ResultType,
00258             ResultType (*)(BaseLhs&, BaseRhs&)> backEnd_;
00259
00260     public:
00261         template <class SomeLhs, class SomeRhs>
00262         void Add(ResultType (*pFun)(BaseLhs&, BaseRhs&))
00263         {
00264             return backEnd_.template Add<SomeLhs, SomeRhs>(pFun);
00265         }
00266
00267         template <class SomeLhs, class SomeRhs,
00268             ResultType (*callback)(SomeLhs&, SomeRhs&)>
00269         void Add()
00270         {
00271         typedef Private::FnDispatcherHelper<
00272                     BaseLhs, BaseRhs,
00273                     SomeLhs, SomeRhs,
00274                     ResultType,
00275                     CastingPolicy<SomeLhs,BaseLhs>,
00276                     CastingPolicy<SomeRhs,BaseRhs>,
00277                     callback> Local;
00278
00279             Add<SomeLhs, SomeRhs>(&Local::Trampoline);
00280         }
00281
00282         template <class SomeLhs, class SomeRhs,
00283             ResultType (*callback)(SomeLhs&, SomeRhs&),
00284             bool symmetric>
00285         void Add(bool = true) // [gcc] dummy bool
00286         {
00287         typedef Private::FnDispatcherHelper<
00288                     BaseLhs, BaseRhs,
00289                     SomeLhs, SomeRhs,
00290                     ResultType,
00291                     CastingPolicy<SomeLhs,BaseLhs>,
00292                     CastingPolicy<SomeRhs,BaseRhs>,
00293                     callback> Local;
00294
00295             Add<SomeLhs, SomeRhs>(&Local::Trampoline);
00296             if (symmetric)
00297             {
00298                 Add<SomeRhs, SomeLhs>(&Local::TrampolineR);
00299             }
00300         }
00301
00302         template <class SomeLhs, class SomeRhs>
00303         void Remove()
00304         {
00305             backEnd_.template Remove<SomeLhs, SomeRhs>();
00306         }
00307
00308         ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
00309         {
00310             return backEnd_.Go(lhs, rhs);
00311         }
00312     };
00313
00315 // class template FunctorDispatcherAdaptor
00316 // permits use of FunctorDispatcher under gcc.2.95.2/3
00318
00319     namespace Private
00320     {
00321     template <class BaseLhs, class BaseRhs,
00322           class SomeLhs, class SomeRhs,
00323           typename ResultType,
00324           class CastLhs, class CastRhs,
00325           class Fun, bool SwapArgs>
00326         class FunctorDispatcherHelper
00327         {
00328             Fun fun_;
00329             ResultType Fire(BaseLhs& lhs, BaseRhs& rhs,Int2Type<false>)
00330             {
00331                 return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
00332             }
00333             ResultType Fire(BaseLhs& rhs, BaseRhs& lhs,Int2Type<true>)
00334             {
00335                 return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
00336             }
00337         public:
00338             FunctorDispatcherHelper(const Fun& fun) : fun_(fun) {}
00339
00340             ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
00341             {
00342                 return Fire(lhs,rhs,Int2Type<SwapArgs>());
00343             }
00344         };
00345     }
00346
00348 // class template FunctorDispatcher
00349 // Implements a logarithmic double dispatcher for functors
00350 // Features automated casting
00352
00353     template <class BaseLhs, class BaseRhs = BaseLhs,
00354               typename ResultType = void,
00355               template <class, class> class CastingPolicy = DynamicCaster,
00356               template <class, class, class, class>
00357               class DispatcherBackend = BasicDispatcher>
00358     class FunctorDispatcher
00359     {
00360         typedef LOKI_TYPELIST_2(BaseLhs&, BaseRhs&) ArgsList;
00361         typedef Functor<ResultType, ArgsList, LOKI_DEFAULT_THREADING> FunctorType;
00362
00363         DispatcherBackend<BaseLhs, BaseRhs, ResultType, FunctorType> backEnd_;
00364
00365     public:
00366         template <class SomeLhs, class SomeRhs, class Fun>
00367         void Add(const Fun& fun)
00368         {
00369             typedef Private::FunctorDispatcherHelper<
00370                     BaseLhs, BaseRhs,
00371                     SomeLhs, SomeRhs,
00372                     ResultType,
00373                     CastingPolicy<SomeLhs, BaseLhs>,
00374                     CastingPolicy<SomeRhs, BaseRhs>,
00375                     Fun, false> Adapter;
00376
00377             backEnd_.template Add<SomeLhs, SomeRhs>(FunctorType(Adapter(fun)));
00378     }
00379         template <class SomeLhs, class SomeRhs, bool symmetric, class Fun>
00380         void Add(const Fun& fun)
00381         {
00382         Add<SomeLhs,SomeRhs>(fun);
00383
00384         if (symmetric)
00385         {
00386         // Note: symmetry only makes sense where BaseLhs==BaseRhs
00387                 typedef Private::FunctorDispatcherHelper<
00388                     BaseLhs, BaseLhs,
00389                     SomeLhs, SomeRhs,
00390                     ResultType,
00391                     CastingPolicy<SomeLhs, BaseLhs>,
00392                     CastingPolicy<SomeRhs, BaseLhs>,
00393                     Fun, true> AdapterR;
00394
00395                 backEnd_.template Add<SomeRhs, SomeLhs>(FunctorType(AdapterR(fun)));
00396         }
00397         }
00398
00399         template <class SomeLhs, class SomeRhs>
00400         void Remove()
00401         {
00402             backEnd_.template Remove<SomeLhs, SomeRhs>();
00403         }
00404
00405         ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
00406         {
00407             return backEnd_.Go(lhs, rhs);
00408         }
00409     };
00410 } // namespace Loki
00411
00412
00413
00414 #endif // end file guardian
00415
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: NullType.h Source File

NullType.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_NULLTYPE_INC_
00016 #define LOKI_NULLTYPE_INC_
00017
00018 // $Id: NullType.h 751 2006-10-17 19:50:37Z syntheticpp $
00019
00020
00021 namespace Loki
00022 {
00024 // class NullType
00025 // Used as a placeholder for "no type here"
00026 // Useful as an end marker in typelists
00028
00029     class NullType {};
00030
00031 }   // namespace Loki
00032
00033
00034 #endif // end file guardian
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: OrderedStatic.cpp Source File

OrderedStatic.cpp

00001
00002 // The Loki Library
00003 // Copyright (c) 2005 Peter Kümmel
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012
00013 // $Id: OrderedStatic.cpp 756 2006-10-17 20:05:42Z syntheticpp $
00014
00015
00016 #include <loki/OrderedStatic.h>
00017 #include <limits>
00018
00019 #ifdef min
00020 #undef min
00021 #endif
00022
00023 #ifdef max
00024 #undef max
00025 #endif
00026
00027 namespace Loki
00028 {
00029     namespace Private
00030     {
00031
00032         OrderedStaticCreatorFunc::OrderedStaticCreatorFunc()
00033         {
00034         }
00035
00036         OrderedStaticCreatorFunc::~OrderedStaticCreatorFunc()
00037         {
00038         }
00039
00040
00041         OrderedStaticManagerClass::OrderedStaticManagerClass() :
00042                     staticObjects_(),
00043                     max_longevity_(std::numeric_limits<unsigned int>::min()),
00044                     min_longevity_(std::numeric_limits<unsigned int>::max())
00045         {
00046         }
00047
00048         OrderedStaticManagerClass::~OrderedStaticManagerClass()
00049         {
00050         }
00051
00052         void OrderedStaticManagerClass::createObjects()
00053         {
00054             for(unsigned int longevity=max_longevity_; longevity>=min_longevity_; longevity--)
00055             {
00056                 for(unsigned int i=0; i<staticObjects_.size(); i++)
00057                 {
00058                     Data cur = staticObjects_.at(i);
00059                     if(cur.longevity==longevity)
00060                         ( (*cur.object).*cur.creator )();
00061                 }
00062             }
00063         }
00064
00065         void OrderedStaticManagerClass::registerObject(unsigned int l, OrderedStaticCreatorFunc* o,Creator f)
00066         {
00067             staticObjects_.push_back(Data(l,o,f));
00068
00069             if(l>max_longevity_) max_longevity_=l;
00070             if(l<min_longevity_) min_longevity_=l;
00071         }
00072
00073         OrderedStaticManagerClass::Data::Data(unsigned int l, OrderedStaticCreatorFunc* o, Creator f)
00074             : longevity(l), object(o), creator(f)
00075         {
00076         }
00077
00078     }//namespace Private
00079
00080 } // end namespace Loki
00081
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: OrderedStatic.h Source File

OrderedStatic.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2005 Peter Kümmel
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012 #ifndef LOKI_ORDEREDSTATIC_INC_
00013 #define LOKI_ORDEREDSTATIC_INC_
00014
00015 // $Id: OrderedStatic.h 751 2006-10-17 19:50:37Z syntheticpp $
00016
00017
00018 #include <vector>
00019 #include <iostream>
00020
00021 #include "LokiExport.h"
00022 #include "Singleton.h"
00023 #include "Typelist.h"
00024 #include "Sequence.h"
00025
00026 // usage: see test/OrderedStatic
00027
00028 namespace Loki
00029 {
00030     namespace Private
00031     {
00033         // polymorph base class for OrderedStatic template,
00034         // necessary because of the creator
00036         class LOKI_EXPORT OrderedStaticCreatorFunc
00037         {
00038         public:
00039             virtual void createObject() = 0;
00040
00041         protected:
00042             OrderedStaticCreatorFunc();
00043             virtual ~OrderedStaticCreatorFunc();
00044
00045         private:
00046             OrderedStaticCreatorFunc(const OrderedStaticCreatorFunc&);
00047         };
00048
00050         // template base clase for OrderedStatic template,
00051         // common for all specializations
00053         template<class T>
00054         class OrderedStaticBase : public OrderedStaticCreatorFunc
00055         {
00056         public:
00057             T& operator*()
00058             {
00059                 return *val_;
00060             }
00061
00062             T* operator->()
00063             {
00064                 return val_;
00065             }
00066
00067         protected:
00068
00069             OrderedStaticBase(unsigned int longevity) :  val_(0), longevity_(longevity)
00070             {
00071             }
00072
00073             virtual ~OrderedStaticBase()
00074             {
00075             }
00076
00077             void SetLongevity(T* ptr)
00078             {
00079                 val_=ptr;
00080                 Loki::SetLongevity(val_,longevity_);
00081             }
00082
00083         private:
00084             OrderedStaticBase();
00085             OrderedStaticBase(const OrderedStaticBase&);
00086             OrderedStaticBase& operator=(const OrderedStaticBase&);
00087             T* val_;
00088             unsigned int longevity_;
00089
00090         };
00091
00093         // OrderedStaticManagerClass implements details
00094         // OrderedStaticManager is then defined as a Singleton
00096         class LOKI_EXPORT OrderedStaticManagerClass
00097         {
00098         public:
00099             OrderedStaticManagerClass();
00100             virtual ~OrderedStaticManagerClass();
00101
00102             typedef void (OrderedStaticCreatorFunc::*Creator)();
00103
00104             void createObjects();
00105             void registerObject(unsigned int longevity,OrderedStaticCreatorFunc*,Creator);
00106
00107         private:
00108             OrderedStaticManagerClass(const OrderedStaticManagerClass&);
00109             OrderedStaticManagerClass& operator=(const OrderedStaticManagerClass&);
00110
00111             struct Data
00112             {
00113                 Data(unsigned int,OrderedStaticCreatorFunc*, Creator);
00114                 unsigned int longevity;
00115                 OrderedStaticCreatorFunc* object;
00116                 Creator creator;
00117             };
00118
00119             std::vector<Data> staticObjects_;
00120             unsigned int max_longevity_;
00121             unsigned int min_longevity_;
00122         };
00123
00124     }// namespace Private
00125
00127     // OrderedStaticManager is only a Singleton typedef
00129
00130     typedef Loki::SingletonHolder
00131     <
00132         Loki::Private::OrderedStaticManagerClass,
00133         Loki::CreateUsingNew,
00134         Loki::NoDestroy,
00135         Loki::SingleThreaded
00136     >
00137     OrderedStaticManager;
00138
00140     // template OrderedStatic template:
00141     // L        : longevity
00142     // T        : object type
00143     // TList    : creator parameters
00145
00146     template<unsigned int L, class T, class TList = Loki::NullType>
00147     class OrderedStatic;
00148
00149
00151     // OrderedStatic specializations
00153
00154     template<unsigned int L, class T>
00155     class OrderedStatic<L, T, Loki::NullType> : public Private::OrderedStaticBase<T>
00156     {
00157     public:
00158         OrderedStatic() : Private::OrderedStaticBase<T>(L)
00159         {
00160             OrderedStaticManager::Instance().registerObject
00161                                 (L,this,&Private::OrderedStaticCreatorFunc::createObject);
00162         }
00163
00164         void createObject()
00165         {
00166             Private::OrderedStaticBase<T>::SetLongevity(new T);
00167         }
00168
00169     private:
00170         OrderedStatic(const OrderedStatic&);
00171         OrderedStatic& operator=(const OrderedStatic&);
00172     };
00173
00174     template<unsigned int L, class T, typename P1>
00175     class OrderedStatic<L, T, Loki::Seq<P1> > : public Private::OrderedStaticBase<T>
00176     {
00177     public:
00178         OrderedStatic(P1 p) : Private::OrderedStaticBase<T>(L), para_(p)
00179         {
00180             OrderedStaticManager::Instance().registerObject
00181                                 (L,this,&Private::OrderedStaticCreatorFunc::createObject);
00182         }
00183
00184         void createObject()
00185         {
00186             Private::OrderedStaticBase<T>::SetLongevity(new T(para_));
00187         }
00188
00189     private:
00190         OrderedStatic();
00191         OrderedStatic(const OrderedStatic&);
00192         OrderedStatic& operator=(const OrderedStatic&);
00193         P1 para_;
00194     };
00195
00196     template<unsigned int L, class T, typename P1>
00197     class OrderedStatic<L, T,  P1(*)() > : public Private::OrderedStaticBase<T>
00198     {
00199     public:
00200
00201         typedef P1(*Func)();
00202
00203         OrderedStatic(Func p) : Private::OrderedStaticBase<T>(L), para_(p)
00204         {
00205             OrderedStaticManager::Instance().registerObject
00206                                 (L,this,&Private::OrderedStaticCreatorFunc::createObject);
00207         }
00208
00209         void createObject()
00210         {
00211             Private::OrderedStaticBase<T>::SetLongevity(new T(para_()));
00212         }
00213
00214     private:
00215         OrderedStatic();
00216         OrderedStatic(const OrderedStatic&);
00217         OrderedStatic& operator=(const OrderedStatic&);
00218         Func para_;
00219     };
00220
00221 }// namespace Loki
00222
00223
00224 #endif // end file guardian
00225
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Pimpl.h Source File

Pimpl.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 Peter Kümmel
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012 #ifndef LOKI_PIMPL_INC_
00013 #define LOKI_PIMPL_INC_
00014
00015 // $Id: Pimpl.h 751 2006-10-17 19:50:37Z syntheticpp $
00016
00017
00019
00020 #ifndef LOKI_INHERITED_PIMPL_NAME
00021 #define LOKI_INHERITED_PIMPL_NAME d
00022 #endif
00023
00024 #ifndef LOKI_INHERITED_RIMPL_NAME
00025 #define LOKI_INHERITED_RIMPL_NAME d
00026 #endif
00027
00028 namespace Loki
00029 {
00030
00038
00039     template<class T>
00040     struct ConstPropPtr
00041     {
00042         explicit ConstPropPtr(T* p) : ptr_(p) {}
00043         ~ConstPropPtr() { delete  ptr_; ptr_ = 0; }
00044         T* operator->()    { return  ptr_; }
00045         T& operator*()    { return *ptr_; }
00046         const T* operator->() const    { return  ptr_; }
00047         const T& operator*()  const    { return *ptr_; }
00048
00049     private:
00050         ConstPropPtr();
00051         ConstPropPtr(const ConstPropPtr&);
00052         ConstPropPtr& operator=(const ConstPropPtr&);
00053         T* ptr_;
00054     };
00055
00056
00069
00070     template
00071     <
00072         class T,
00073         typename Pointer = ConstPropPtr<T>
00074     >
00075     class Pimpl
00076     {
00077     public:
00078
00079         typedef T Impl;
00080
00081         Pimpl() : ptr_(new T)
00082         {}
00083
00084         ~Pimpl()
00085         {
00086             // Don't compile with incomplete type
00087             //
00088             // If compilation breaks here make sure
00089             // the compiler does not auto-generate the
00090             // destructor of the class hosting the pimpl:
00091             // - implement the destructor of the class
00092             // - don't inline the destructor
00093             typedef char T_must_be_defined[sizeof(T) ? 1 : -1 ];
00094         }
00095
00096
00097         T* operator->()
00098         {
00099             return ptr_.operator->();
00100         }
00101
00102         T& operator*()
00103         {
00104             return ptr_.operator*();
00105         }
00106
00107         const T* operator->() const
00108         {
00109             return ptr_.operator->();
00110         }
00111
00112         const T& operator*() const
00113         {
00114             return ptr_.operator*();
00115         }
00116
00117         Pointer& wrapped()
00118         {
00119             return ptr_;
00120         }
00121
00122         const Pointer& wrapped() const
00123         {
00124             return ptr_;
00125         }
00126
00127
00128     private:
00129         Pimpl(const Pimpl&);
00130         Pimpl& operator=(const Pimpl&);
00131
00132         Pointer ptr_;
00133     };
00134
00135
00136     template<class T, typename Pointer = ConstPropPtr<T> >
00137     struct PimplOwner
00138     {
00139         Pimpl<T,Pointer> LOKI_INHERITED_PIMPL_NAME;
00140     };
00141
00142
00150
00151     template<class T>
00152     struct ImplOf;
00153
00154
00162
00163
00164     template<class T, template<class> class Ptr = ConstPropPtr>
00165     struct PimplOf
00166     {
00167         typedef T Impl;
00168
00169         // declare pimpl
00170         typedef Pimpl<ImplOf<T>, Ptr<ImplOf<T> > > Type;
00171
00172         // inherit pimpl
00173         typedef PimplOwner<ImplOf<T>, Ptr<ImplOf<T> > > Owner;
00174     };
00175
00176
00177     template<class T, class UsedPimpl = typename PimplOf<T>::Type >
00178     struct RimplOf
00179     {
00180         typedef typename UsedPimpl::Impl & Type;
00181
00182         class Owner
00183         {
00184             UsedPimpl pimpl;
00185
00186         public:
00187             Owner() : LOKI_INHERITED_RIMPL_NAME(*pimpl)
00188             {}
00189
00190             Type LOKI_INHERITED_RIMPL_NAME;
00191         };
00192
00193     };
00194
00195 }
00196
00197 #endif // end file guardian
00198
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: RefToValue.h Source File

RefToValue.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 Richard Sposato
00004 // Copyright (c) 2006 Peter Kümmel
00005 // Permission to use, copy, modify, distribute and sell this software for any
00006 //     purpose is hereby granted without fee, provided that the above copyright
00007 //     notice appear in all copies and that both that copyright notice and this
00008 //     permission notice appear in supporting documentation.
00009 // The authors make no representations about the
00010 //     suitability of this software for any purpose. It is provided "as is"
00011 //     without express or implied warranty.
00013 #ifndef LOKI_REFTOVALUE_INC_
00014 #define LOKI_REFTOVALUE_INC_
00015
00016 // $Id: RefToValue.h 751 2006-10-17 19:50:37Z syntheticpp $
00017
00018
00019 namespace Loki
00020 {
00021
00029
00030     template <class T>
00031     class RefToValue
00032     {
00033     public:
00034
00035         RefToValue(T& ref) : ref_(ref)
00036         {}
00037
00038         RefToValue(const RefToValue& rhs) : ref_(rhs.ref_)
00039         {}
00040
00041         operator T& () const
00042         {
00043             return ref_;
00044         }
00045
00046     private:
00047         // Disable - not implemented
00048         RefToValue();
00049         RefToValue& operator=(const RefToValue&);
00050
00051         T& ref_;
00052     };
00053
00054
00059
00060     template <class T>
00061     inline RefToValue<T> ByRef(T& t)
00062     {
00063         return RefToValue<T>(t);
00064     }
00065
00066 }
00067
00068
00069 #endif // end file guardian
00070
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Register.h Source File

Register.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 Peter Kümmel
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012 #ifndef LOKI_REGISTER_INC_
00013 #define LOKI_REGISTER_INC_
00014
00015 // $Id: Register.h 776 2006-11-09 13:12:57Z syntheticpp $
00016
00017
00018 #include "TypeManip.h"
00019 #include "HierarchyGenerators.h"
00020
00022
00023 namespace Loki
00024 {
00025
00027     //
00028     //  Helper classes/functions for RegisterByCreateSet
00029     //
00031
00036     template<class t> bool RegisterFunction();
00037
00042     template<class t> bool UnRegisterFunction();
00043
00044     namespace Private
00045     {
00046         template<class T>
00047         struct RegisterOnCreate
00048         {
00049             RegisterOnCreate()  { RegisterFunction<T>(); }
00050         };
00051
00052         template<class T>
00053         struct UnRegisterOnDelete
00054         {
00055             ~UnRegisterOnDelete() { UnRegisterFunction<T>(); }
00056         };
00057
00058         template<class T>
00059         struct RegisterOnCreateElement
00060         {
00061             RegisterOnCreate<T> registerObj;
00062         };
00063
00064         template<class T>
00065         struct UnRegisterOnDeleteElement
00066         {
00067             UnRegisterOnDelete<T> unregisterObj;
00068         };
00069     }
00070
00080
00081     template<typename ElementList>
00082     struct RegisterOnCreateSet
00083         : GenScatterHierarchy<ElementList, Private::RegisterOnCreateElement>
00084     {};
00085
00095     template<typename ElementList>
00096     struct UnRegisterOnDeleteSet
00097         : GenScatterHierarchy<ElementList, Private::UnRegisterOnDeleteElement>
00098     {};
00099
00100
00110
00111
00112 #define LOKI_CONCATE(a,b,c,d) a ## b ## c ## d
00113 #define LOKI_CONCAT(a,b,c,d) LOKI_CONCATE(a,b,c,d)
00114
00115 #define LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST )                                \
00116                                                                                 \
00117     struct LOKI_CONCAT(check_,CLASS,_isInList_,LIST)                            \
00118     {                                                                           \
00119         typedef int LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST);         \
00120     };                                                                          \
00121     typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1,           \
00122                         CLASS,                                                  \
00123                         LOKI_CONCAT(check_,CLASS,_isInList_,LIST)>              \
00124                         ::Result LOKI_CONCAT(CLASS,isInList,LIST,result);       \
00125     typedef LOKI_CONCAT(CLASS,isInList,LIST,result)::                           \
00126                         LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST)      \
00127                         LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList__,LIST);
00128
00129
00130 } // namespace Loki
00131
00132
00133 #endif // end file guardian
00134
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: SafeFormat.cpp Source File

SafeFormat.cpp

00001
00002 // Copyright (c) 2005 by Andrei Alexandrescu
00003 // Copyright (c) 2006 Peter Kümmel
00004 // Permission to use, copy, modify, distribute, and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the suitability of this software
00009 //     for any purpose. It is provided "as is" without express or implied
00010 //     warranty.
00012
00013 // $Id: SafeFormat.cpp 756 2006-10-17 20:05:42Z syntheticpp $
00014
00015
00016 #include <loki/SafeFormat.h>
00017
00018
00019 namespace Loki
00020 {
00021
00022     // Crude writing method: writes straight to the file, unbuffered
00023     // Must be combined with a buffer to work properly (and efficiently)
00024
00025     void write(std::FILE* f, const char* from, const char* to) {
00026         assert(from <= to);
00027         ::std::fwrite(from, 1, to - from, f);
00028     }
00029
00030     // Write to a string
00031
00032     void write(std::string& s, const char* from, const char* to) {
00033         assert(from <= to);
00034         s.append(from, to);
00035     }
00036
00037     // Write to a stream
00038
00039     void write(std::ostream& f, const char* from, const char* to) {
00040         assert(from <= to);
00041         f.write(from, std::streamsize(to - from));
00042     }
00043
00045     // PrintfState class template
00046     // Holds the formatting state, and implements operator() to format stuff
00047     // Todo: make sure errors are handled properly
00049
00050
00051     PrintfState<std::FILE*, char> Printf(const char* format) {
00052         return PrintfState<std::FILE*, char>(stdout, format);
00053     }
00054
00055     PrintfState<std::FILE*, char> Printf(const std::string& format) {
00056         return PrintfState<std::FILE*, char>(stdout, format.c_str());
00057     }
00058
00059     PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const char* format) {
00060         return PrintfState<std::FILE*, char>(f, format);
00061     }
00062
00063     PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const std::string& format) {
00064         return PrintfState<std::FILE*, char>(f, format.c_str());
00065     }
00066
00067     PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const char* format) {
00068         return PrintfState<std::ostream&, char>(f, format);
00069     }
00070
00071     PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const std::string& format) {
00072         return PrintfState<std::ostream&, char>(f, format.c_str());
00073     }
00074
00075     PrintfState<std::string&, char> SPrintf(std::string& s, const char* format) {
00076         return PrintfState<std::string&, char>(s, format);
00077     }
00078
00079     PrintfState<std::string&, char> SPrintf(std::string& s, const std::string& format) {
00080         return PrintfState<std::string&, char>(s, format.c_str());
00081     }
00082
00083
00084 } // end namespace Loki
00085
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: SafeFormat.h Source File

SafeFormat.h

00001
00002 // Copyright (c) 2005 by Andrei Alexandrescu
00003 // Copyright (c) 2006 Peter Kümmel
00004 // Permission to use, copy, modify, distribute, and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the suitability of this software
00009 //     for any purpose. It is provided "as is" without express or implied
00010 //     warranty.
00012 #ifndef LOKI_SAFEFORMAT_INC_
00013 #define LOKI_SAFEFORMAT_INC_
00014
00015 // $Id: SafeFormat.h 747 2006-10-17 19:48:40Z syntheticpp $
00016
00017
00019 // This file contains definitions for SafePrintf. SafeScanf coming soon (the
00020 //   design is similar).
00021 // See Alexandrescu, Andrei: Type-safe Formatting, C/C++ Users Journal, Aug 2005
00023
00024 #include <cstdio>
00025 #include <string>
00026 #include <stdexcept>
00027 #include <utility>
00028 #include <cassert>
00029 #include <locale>
00030 #include <iostream>
00031
00032 #include <loki/LokiExport.h>
00033
00034
00035 // long is 32 bit on 64-bit Windows!
00036 // intptr_t used to get 64 bit on Win64
00037 #if defined(_WIN32) || defined(_WIN64)
00038 #  define LOKI_SAFEFORMAT_SIGNED_LONG intptr_t
00039 #  define LOKI_SAFEFORMAT_UNSIGNED_LONG uintptr_t
00040 #else
00041 #  define LOKI_SAFEFORMAT_SIGNED_LONG signed long
00042 #  define LOKI_SAFEFORMAT_UNSIGNED_LONG unsigned long
00043 #endif
00044
00045 // Windows headers could have min/max defined
00046 #ifdef max
00047 #  undef max
00048 #endif
00049 #ifdef min
00050 #  undef min
00051 #endif
00052
00053 namespace Loki
00054 {
00055
00056     // Crude writing method: writes straight to the file, unbuffered
00057     // Must be combined with a buffer to work properly (and efficiently)
00058     LOKI_EXPORT
00059     void write(std::FILE* f, const char* from, const char* to);
00060
00061     // Write to an ostream
00062     LOKI_EXPORT
00063     void write(std::ostream& f, const char* from, const char* to);
00064
00065     // Write to a string
00066     LOKI_EXPORT
00067     void write(std::string& s, const char* from, const char* to);
00068
00069     // Write to a fixed-size buffer
00070     template <class Char>
00071     void write(std::pair<Char*, std::size_t>& s, const Char* from, const Char* to) {
00072         assert(from <= to);
00073         if(from + s.second < to)
00074             throw std::overflow_error("");
00075         // s.first: position one past the final copied element
00076         s.first = std::copy(from, to, s.first);
00077         // remaining buffer size
00078         s.second -= to - from;
00079     }
00080
00082     // PrintfState class template
00083     // Holds the formatting state, and implements operator() to format stuff
00084     // Todo: make sure errors are handled properly
00086
00087     template <class Device, class Char>
00088     struct PrintfState {
00089         PrintfState(Device dev, const Char * format)
00090                 : device_(dev)
00091                 , format_(format)
00092                 , width_(0)
00093                 , prec_(0)
00094                 , flags_(0)
00095                 , result_(0) {
00096             Advance();
00097         }
00098
00099         ~PrintfState() {
00100         }
00101
00102         #define LOKI_PRINTF_STATE_FORWARD(type) \
00103             PrintfState& operator()(type par) {\
00104                 return (*this)(static_cast< LOKI_SAFEFORMAT_UNSIGNED_LONG >(par)); \
00105             }
00106
00107         LOKI_PRINTF_STATE_FORWARD(bool)
00108         LOKI_PRINTF_STATE_FORWARD(char)
00109         LOKI_PRINTF_STATE_FORWARD(signed char)
00110         LOKI_PRINTF_STATE_FORWARD(unsigned char)
00111         LOKI_PRINTF_STATE_FORWARD(signed short)
00112         LOKI_PRINTF_STATE_FORWARD(unsigned short)
00113         LOKI_PRINTF_STATE_FORWARD(signed int)
00114         LOKI_PRINTF_STATE_FORWARD(signed long)
00115 #if (defined(_WIN32) || defined(_WIN64))
00116         LOKI_PRINTF_STATE_FORWARD(unsigned long)
00117 #else
00118         // on Windows already defined by uintptr_t
00119         LOKI_PRINTF_STATE_FORWARD(unsigned int)
00120 #endif
00121
00122         // Print (or gobble in case of the "*" specifier) an int
00123         PrintfState& operator()(LOKI_SAFEFORMAT_UNSIGNED_LONG i) {
00124             if (result_ == -1) return *this; // don't even bother
00125             // % [flags] [width] [.prec] [modifier] type_char
00126             // Fetch the flags
00127             ReadFlags();
00128             if (*format_ == '*') {
00129                 // read the width and get out
00130                 SetWidth(static_cast<size_t>(i));
00131                 ++format_;
00132                 return *this;
00133             }
00134             ReadWidth();
00135             // precision
00136             if (*format_ == '.') {
00137                 // deal with precision
00138                 if (format_[1] == '*') {
00139                     // read the precision and get out
00140                     SetPrec(static_cast<size_t>(i));
00141                     format_ += 2;
00142                     return *this;
00143                 }
00144                 ReadPrecision();
00145             }
00146             ReadModifiers();
00147             // input size modifier
00148             if (ForceShort()) {
00149                 // short int
00150                 const Char c = *format_;
00151                 if (c == 'x' || c == 'X' || c == 'u' || c == 'o') {
00152                     i = static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(static_cast<unsigned short>(i));
00153                 }
00154             }
00155             FormatWithCurrentFlags(i);
00156             return *this;
00157         }
00158
00159         PrintfState& operator()(void* n) {
00160             if (result_ == -1) return *this; // don't even bother
00161             PrintUsing_snprintf(n,"p");
00162             return *this;
00163         }
00164
00165         PrintfState& operator()(double n) {
00166             if (result_ == -1) return *this; // don't even bother
00167             PrintUsing_snprintf(n,"eEfgG");
00168             return *this;
00169         }
00170
00171         PrintfState& operator()(long double n) {
00172             if (result_ == -1) return *this; // don't even bother
00173             PrintUsing_snprintf(n,"eEfgG");
00174             return *this;
00175         }
00176
00177         // Store the number of characters printed so far
00178         PrintfState& operator()(int * pi) {
00179             return StoreCountHelper(pi);
00180         }
00181
00182         // Store the number of characters printed so far
00183         PrintfState& operator()(short * pi) {
00184             return StoreCountHelper(pi);
00185         }
00186
00187         // Store the number of characters printed so far
00188         PrintfState& operator()(long * pi) {
00189             return StoreCountHelper(pi);
00190         }
00191
00192         PrintfState& operator()(const std::string& stdstr) {
00193             return operator()(stdstr.c_str());
00194         }
00195
00196         PrintfState& operator()(const char *const s) {
00197             if (result_ == -1) return *this;
00198             ReadLeaders();
00199             const char fmt = *format_;
00200             if (fmt == 'p') {
00201                 FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(s));
00202                 return *this;
00203             }
00204             if (fmt != 's') {
00205                 result_ = -1;
00206                 return *this;
00207             }
00208             const size_t len = std::min(strlen(s), prec_);
00209             if (width_ > len) {
00210                 if (LeftJustify()) {
00211                     Write(s, s + len);
00212                     Fill(' ', width_ - len);
00213                 } else {
00214                     Fill(' ', width_ - len);
00215                     Write(s, s + len);
00216                 }
00217             } else {
00218                 Write(s, s + len);
00219             }
00220             Next();
00221             return *this;
00222         }
00223
00224         PrintfState& operator()(const void *const p) {
00225             return (*this)(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(p));
00226         }
00227
00228         // read the result
00229         operator int() const {
00230             return static_cast<int>(result_);
00231         }
00232
00233     private:
00234         PrintfState& operator=(const PrintfState&);
00235         template <typename T>
00236         PrintfState& StoreCountHelper(T *const pi) {
00237             if (result_ == -1) return *this; // don't even bother
00238             ReadLeaders();
00239             const char fmt = *format_;
00240             if (fmt == 'p') { // pointer
00241                 FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(pi));
00242                 return *this;
00243             }
00244             if (fmt != 'n') {
00245                 result_ = -1;
00246                 return *this;
00247             }
00248             assert(pi != 0);
00249             *pi = result_;
00250             Next();
00251             return *this;
00252         }
00253
00254         void FormatWithCurrentFlags(const LOKI_SAFEFORMAT_UNSIGNED_LONG i) {
00255             // look at the format character
00256             Char formatChar = *format_;
00257             bool isSigned = formatChar == 'd' || formatChar == 'i';
00258             if (formatChar == 'p') {
00259                 formatChar = 'x'; // pointers go to hex
00260                 SetAlternateForm(); // printed with '0x' in front
00261                 isSigned = true; // that's what gcc does
00262             }
00263             if (!strchr("cdiuoxX", formatChar)) {
00264                 result_ = -1;
00265                 return;
00266             }
00267             Char buf[
00268                 sizeof(LOKI_SAFEFORMAT_UNSIGNED_LONG) * 3 // digits
00269                 + 1 // sign or ' '
00270                 + 2 // 0x or 0X
00271                 + 1]; // terminating zero
00272             const Char *const bufEnd = buf + (sizeof(buf) / sizeof(Char));
00273             Char * bufLast = buf + (sizeof(buf) / sizeof(Char) - 1);
00274             Char signChar = 0;
00275             unsigned int base = 10;
00276
00277             if (formatChar == 'c') {
00278                 // Format only one character
00279                 // The 'fill with zeros' flag is ignored
00280                 ResetFillZeros();
00281                 *bufLast = static_cast<char>(i);
00282             } else {
00283                 // TODO: inefficient code, refactor
00284                 const bool negative = isSigned && static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i) < 0;
00285                 if (formatChar == 'o') base = 8;
00286                 else if (formatChar == 'x' || formatChar == 'X') base = 16;
00287                 bufLast = isSigned
00288                     ? RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i), bufLast, base,
00289                         formatChar == 'X')
00290                     : RenderWithoutSign(i, bufLast, base,
00291                         formatChar == 'X');
00292                 // Add the sign
00293                 if (isSigned) {
00294                     negative ? signChar = '-'
00295                     : ShowSignAlways() ? signChar = '+'
00296                     : Blank() ? signChar = ' '
00297                     : 0;
00298                 }
00299             }
00300             // precision
00301             size_t
00302                 countDigits = bufEnd - bufLast,
00303                 countZeros = prec_ != size_t(-1) && countDigits < prec_ &&
00304                         formatChar != 'c'
00305                     ? prec_ - countDigits
00306                     : 0,
00307                 countBase = base != 10 && AlternateForm() && i != 0
00308                     ? (base == 16 ? 2 : countZeros > 0 ? 0 : 1)
00309                     : 0,
00310                 countSign = (signChar != 0),
00311                 totalPrintable = countDigits + countZeros + countBase + countSign;
00312             size_t countPadLeft = 0, countPadRight = 0;
00313             if (width_ > totalPrintable) {
00314                 if (LeftJustify()) {
00315                     countPadRight = width_ - totalPrintable;
00316                     countPadLeft = 0;
00317                 } else {
00318                     countPadLeft = width_ - totalPrintable;
00319                     countPadRight = 0;
00320                 }
00321             }
00322             if (FillZeros() && prec_ == size_t(-1)) {
00323                 // pad with zeros and no precision - transfer padding to precision
00324                 countZeros = countPadLeft;
00325                 countPadLeft = 0;
00326             }
00327             // ok, all computed, ready to print to device
00328             Fill(' ', countPadLeft);
00329             if (signChar != 0) Write(&signChar, &signChar + 1);
00330             if (countBase > 0) Fill('0', 1);
00331             if (countBase == 2) Fill(formatChar, 1);
00332             Fill('0', countZeros);
00333             Write(bufLast, bufEnd);
00334             Fill(' ', countPadRight);
00335             // done, advance
00336             Next();
00337         }
00338
00339         void Write(const Char* b, const Char* e) {
00340             if (result_ < 0) return;
00341             const LOKI_SAFEFORMAT_SIGNED_LONG x = e - b;
00342             write(device_, b, e);
00343             result_ += x;
00344         }
00345
00346         template <class Value>
00347         void PrintUsing_snprintf(Value n, const char* check_fmt_char) {
00348             const Char *const fmt = format_ - 1;
00349             assert(*fmt == '%');
00350             // enforce format string validity
00351             ReadLeaders();
00352             // enforce format spec
00353             if (!strchr(check_fmt_char, *format_)) {
00354                 result_ = -1;
00355                 return;
00356             }
00357             // format char validated, copy it to a temp and use legacy sprintf
00358             ++format_;
00359             Char fmtBuf[128], resultBuf[1024];
00360             if (format_  >= fmt + sizeof(fmtBuf) / sizeof(Char)) {
00361                 result_ = -1;
00362                 return;
00363             }
00364             memcpy(fmtBuf, fmt, (format_ - fmt) * sizeof(Char));
00365             fmtBuf[format_ - fmt] = 0;
00366
00367             const int stored =
00368 #ifdef _MSC_VER
00369 #if _MSC_VER < 1400
00370             _snprintf
00371 #else
00372             _snprintf_s
00373 #endif
00374 #else
00375             snprintf
00376 #endif
00377                      (resultBuf, sizeof(resultBuf) / sizeof(Char), fmtBuf, n);
00378
00379             if (stored < 0) {
00380                 result_ = -1;
00381                 return;
00382             }
00383             Write(resultBuf, resultBuf + strlen(resultBuf));
00384             Advance(); // output stuff to the next format directive
00385         }
00386
00387         void Fill(const Char c, size_t n) {
00388             for (; n > 0; --n) {
00389                 Write(&c, &c + 1);
00390             }
00391         }
00392
00393         Char* RenderWithoutSign(LOKI_SAFEFORMAT_UNSIGNED_LONG n, char* bufLast,
00394                 unsigned int base, bool uppercase) {
00395             const Char hex1st = uppercase ? 'A' : 'a';
00396             for (;;) {
00397                 const LOKI_SAFEFORMAT_UNSIGNED_LONG next = n / base;
00398 #ifdef _MSC_VER
00399 #pragma warning(push)
00400 #pragma warning(disable: 4244)
00401 #endif
00402                 Char c = n - next * base;
00403 #ifdef _MSC_VER
00404 #pragma warning(pop)
00405 #endif
00406                 c += (c <= 9) ? '0' : hex1st - 10;
00407                 *bufLast = c;
00408                 n = next;
00409                 if (n == 0) break;
00410                 --bufLast;
00411             }
00412             return bufLast;
00413         }
00414
00415         char* RenderWithoutSign(LOKI_SAFEFORMAT_SIGNED_LONG n, char* bufLast, unsigned int base,
00416                 bool uppercase) {
00417             if (n != LONG_MIN) {
00418                 return RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n < 0 ? -n : n),
00419                     bufLast, base, uppercase);
00420             }
00421             // annoying corner case
00422             char* save = bufLast;
00423             ++n;
00424             bufLast = RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n),
00425                 bufLast, base, uppercase);
00426             --(*save);
00427             return bufLast;
00428         }
00429
00430         void Next() {
00431             ++format_;
00432             Advance();
00433         }
00434
00435         void Advance() {
00436             ResetAll();
00437             const Char* begin = format_;
00438             for (;;) {
00439                 if (*format_ == '%') {
00440                     if (format_[1] != '%') { // It's a format specifier
00441                         Write(begin, format_);
00442                         ++format_;
00443                         break;
00444                     }
00445                     // It's a "%%"
00446                     Write(begin, ++format_);
00447                     begin = ++format_;
00448                     continue;
00449                 }
00450                 if (*format_ == 0) {
00451                     Write(begin, format_);
00452                     break;
00453                 }
00454                 ++format_;
00455             }
00456         }
00457
00458         void ReadFlags() {
00459             for (;; ++format_) {
00460                 switch (*format_) {
00461                     case '-': SetLeftJustify(); break;
00462                     case '+': SetShowSignAlways(); break;
00463                     case ' ': SetBlank(); break;
00464                     case '#': SetAlternateForm(); break;
00465                     case '0': SetFillZeros(); break;
00466                     default: return;
00467                 }
00468             }
00469         }
00470
00471         void ParseDecimalSizeT(size_t& dest) {
00472             if (!std::isdigit(*format_, std::locale())) return;
00473             size_t r = 0;
00474             do {
00475                 // TODO: inefficient - rewrite
00476                 r *= 10;
00477                 r += *format_ - '0';
00478                 ++format_;
00479             } while (std::isdigit(*format_, std::locale()));
00480             dest = r;
00481         }
00482
00483         void ReadWidth() {
00484             ParseDecimalSizeT(width_);
00485         }
00486
00487         void ReadPrecision() {
00488             assert(*format_ == '.');
00489             ++format_;
00490             ParseDecimalSizeT(prec_);
00491         }
00492
00493         void ReadModifiers() {
00494             switch (*format_) {
00495                 case 'h': SetForceShort(); ++format_; break;
00496                 case 'l': ++format_; break;
00497                 // more (C99 and platform-specific modifiers) to come
00498             }
00499         }
00500
00501         void ReadLeaders() {
00502             ReadFlags();
00503             ReadWidth();
00504             if (*format_ == '.') ReadPrecision();
00505             ReadModifiers();
00506         }
00507
00508         enum {
00509             leftJustify = 1,
00510             showSignAlways = 2,
00511             blank = 4,
00512             alternateForm = 8,
00513             fillZeros = 16,
00514             forceShort = 32
00515         };
00516
00517         bool LeftJustify() const { return (flags_ & leftJustify) != 0; }
00518         bool ShowSignAlways() const { return (flags_ & showSignAlways) != 0; }
00519         void SetWidth(size_t w) { width_  = w; }
00520         void SetLeftJustify() { flags_  |= leftJustify; }
00521         void SetShowSignAlways() { flags_ |= showSignAlways; }
00522         bool Blank() const { return (flags_ & blank) != 0; }
00523         bool AlternateForm() const { return (flags_ & alternateForm) != 0; }
00524         bool FillZeros() const { return (flags_ & fillZeros) != 0; }
00525         bool ForceShort() const { return (flags_ & forceShort) != 0; }
00526
00527         void SetPrec(size_t p) { prec_ = p; }
00528         void SetBlank() { flags_ |= blank; }
00529         void SetAlternateForm() { flags_ |=  alternateForm; }
00530         void SetFillZeros() { flags_ |= fillZeros; }
00531         void ResetFillZeros() { flags_ &= ~fillZeros; }
00532         void SetForceShort() { flags_ |= forceShort; }
00533
00534         void ResetAll() {
00535             assert(result_ != EOF);
00536             width_ = 0;
00537             prec_ = size_t(-1);
00538             flags_ = 0;
00539         }
00540
00541         // state
00542         Device device_;
00543         const Char* format_;
00544         size_t width_;
00545         size_t prec_;
00546         unsigned int flags_;
00547         LOKI_SAFEFORMAT_SIGNED_LONG result_;
00548     };
00549
00550     LOKI_EXPORT
00551     PrintfState<std::FILE*, char> Printf(const char* format);
00552
00553     LOKI_EXPORT
00554     PrintfState<std::FILE*, char> Printf(const std::string& format);
00555
00556     LOKI_EXPORT
00557     PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const char* format);
00558
00559     LOKI_EXPORT
00560     PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const std::string& format);
00561
00562     LOKI_EXPORT
00563     PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const char* format);
00564
00565     LOKI_EXPORT
00566     PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const std::string& format);
00567
00568     LOKI_EXPORT
00569     PrintfState<std::string&, char> SPrintf(std::string& s, const char* format);
00570
00571     LOKI_EXPORT
00572     PrintfState<std::string&, char> SPrintf(std::string& s, const std::string& format);
00573
00574     template <class T, class Char>
00575     PrintfState<T&, Char> XPrintf(T& device, const Char* format) {
00576         return PrintfState<T&, Char>(device, format);
00577     }
00578
00579     template <class T>
00580     PrintfState<T&, char> XPrintf(T& device, const std::string& format) {
00581         return PrintfState<T&, char>(device, format.c_str());
00582     }
00583
00584     template <class Char, std::size_t N>
00585     PrintfState<std::pair<Char*, std::size_t>, Char>
00586     BufPrintf(Char (&buf)[N], const Char* format) {
00587         std::pair<Char*, std::size_t> temp(buf, N);
00588         return PrintfState<std::pair<Char*, std::size_t>, Char>(temp, format);
00589     }
00590
00591 }// namespace Loki
00592
00593
00594 #endif // end file guardian
00595
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: ScopeGuard.h Source File

ScopeGuard.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2000 Andrei Alexandrescu
00004 // Copyright (c) 2000 Petru Marginean
00005 // Copyright (c) 2005 Joshua Lehrer
00006 //
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author makes no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_SCOPEGUARD_INC_
00016 #define LOKI_SCOPEGUARD_INC_
00017
00018 // $Id: ScopeGuard.h 799 2006-12-20 00:37:13Z rich_sposato $
00019
00020
00021 #include <loki/RefToValue.h>
00022
00024
00025 namespace Loki
00026 {
00027
00042
00043     class ScopeGuardImplBase
00044     {
00046         ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
00047
00048     protected:
00049
00050         ~ScopeGuardImplBase()
00051         {}
00052
00054         ScopeGuardImplBase(const ScopeGuardImplBase& other) throw()
00055             : dismissed_(other.dismissed_)
00056         {
00057             other.Dismiss();
00058         }
00059
00060         template <typename J>
00061         static void SafeExecute(J& j) throw()
00062         {
00063             if (!j.dismissed_)
00064                 try
00065                 {
00066                     j.Execute();
00067                 }
00068                 catch(...)
00069                 {}
00070         }
00071
00072         mutable bool dismissed_;
00073
00074     public:
00075         ScopeGuardImplBase() throw() : dismissed_(false)
00076         {}
00077
00078         void Dismiss() const throw()
00079         {
00080             dismissed_ = true;
00081         }
00082     };
00083
00090
00091     typedef const ScopeGuardImplBase& ScopeGuard;
00092
00106
00107     template <typename F>
00108     class ScopeGuardImpl0 : public ScopeGuardImplBase
00109     {
00110     public:
00111         static ScopeGuardImpl0<F> MakeGuard(F fun)
00112         {
00113             return ScopeGuardImpl0<F>(fun);
00114         }
00115
00116         ~ScopeGuardImpl0() throw()
00117         {
00118             SafeExecute(*this);
00119         }
00120
00121         void Execute()
00122         {
00123             fun_();
00124         }
00125
00126     protected:
00127         ScopeGuardImpl0(F fun) : fun_(fun)
00128         {}
00129
00130         F fun_;
00131     };
00132
00133     template <typename F>
00134     inline ScopeGuardImpl0<F> MakeGuard(F fun)
00135     {
00136         return ScopeGuardImpl0<F>::MakeGuard(fun);
00137     }
00138
00153
00154     template <typename F, typename P1>
00155     class ScopeGuardImpl1 : public ScopeGuardImplBase
00156     {
00157     public:
00158         static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
00159         {
00160             return ScopeGuardImpl1<F, P1>(fun, p1);
00161         }
00162
00163         ~ScopeGuardImpl1() throw()
00164         {
00165             SafeExecute(*this);
00166         }
00167
00168         void Execute()
00169         {
00170             fun_(p1_);
00171         }
00172
00173     protected:
00174         ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1)
00175         {}
00176
00177         F fun_;
00178         const P1 p1_;
00179     };
00180
00181     template <typename F, typename P1>
00182     inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
00183     {
00184         return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
00185     }
00186
00201
00202     template <typename F, typename P1, typename P2>
00203     class ScopeGuardImpl2: public ScopeGuardImplBase
00204     {
00205     public:
00206         static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
00207         {
00208             return ScopeGuardImpl2<F, P1, P2>(fun, p1, p2);
00209         }
00210
00211         ~ScopeGuardImpl2() throw()
00212         {
00213             SafeExecute(*this);
00214         }
00215
00216         void Execute()
00217         {
00218             fun_(p1_, p2_);
00219         }
00220
00221     protected:
00222         ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2)
00223         {}
00224
00225         F fun_;
00226         const P1 p1_;
00227         const P2 p2_;
00228     };
00229
00230     template <typename F, typename P1, typename P2>
00231     inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
00232     {
00233         return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
00234     }
00235
00250
00251     template <typename F, typename P1, typename P2, typename P3>
00252     class ScopeGuardImpl3 : public ScopeGuardImplBase
00253     {
00254     public:
00255         static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
00256         {
00257             return ScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3);
00258         }
00259
00260         ~ScopeGuardImpl3() throw()
00261         {
00262             SafeExecute(*this);
00263         }
00264
00265         void Execute()
00266         {
00267             fun_(p1_, p2_, p3_);
00268         }
00269
00270     protected:
00271         ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3)
00272         {}
00273
00274         F fun_;
00275         const P1 p1_;
00276         const P2 p2_;
00277         const P3 p3_;
00278     };
00279
00280     template <typename F, typename P1, typename P2, typename P3>
00281     inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
00282     {
00283         return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3);
00284     }
00285
00300
00301     template < typename F, typename P1, typename P2, typename P3, typename P4 >
00302     class ScopeGuardImpl4 : public ScopeGuardImplBase
00303     {
00304     public:
00305         static ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard(
00306             F fun, P1 p1, P2 p2, P3 p3, P4 p4 )
00307         {
00308             return ScopeGuardImpl4< F, P1, P2, P3, P4 >( fun, p1, p2, p3, p4 );
00309         }
00310
00311         ~ScopeGuardImpl4() throw()
00312         {
00313             SafeExecute( *this );
00314         }
00315
00316         void Execute()
00317         {
00318             fun_( p1_, p2_, p3_, p4_ );
00319         }
00320
00321     protected:
00322         ScopeGuardImpl4( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) :
00323              fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 )
00324         {}
00325
00326         F fun_;
00327         const P1 p1_;
00328         const P2 p2_;
00329         const P3 p3_;
00330         const P4 p4_;
00331     };
00332
00333     template < typename F, typename P1, typename P2, typename P3, typename P4 >
00334     inline ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4 )
00335     {
00336         return ScopeGuardImpl4< F, P1, P2, P3, P4 >::MakeGuard( fun, p1, p2, p3, p4 );
00337     }
00338
00353
00354     template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 >
00355     class ScopeGuardImpl5 : public ScopeGuardImplBase
00356     {
00357     public:
00358         static ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard(
00359             F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
00360         {
00361             return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >( fun, p1, p2, p3, p4, p5 );
00362         }
00363
00364         ~ScopeGuardImpl5() throw()
00365         {
00366             SafeExecute( *this );
00367         }
00368
00369         void Execute()
00370         {
00371             fun_( p1_, p2_, p3_, p4_, p5_ );
00372         }
00373
00374     protected:
00375         ScopeGuardImpl5( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) :
00376              fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ), p5_( p5 )
00377         {}
00378
00379         F fun_;
00380         const P1 p1_;
00381         const P2 p2_;
00382         const P3 p3_;
00383         const P4 p4_;
00384         const P5 p5_;
00385     };
00386
00387     template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 >
00388     inline ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
00389     {
00390         return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >::MakeGuard( fun, p1, p2, p3, p4, p5 );
00391     }
00392
00408
00409     template <class Obj, typename MemFun>
00410     class ObjScopeGuardImpl0 : public ScopeGuardImplBase
00411     {
00412     public:
00413         static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
00414         {
00415             return ObjScopeGuardImpl0<Obj, MemFun>(obj, memFun);
00416         }
00417
00418         ~ObjScopeGuardImpl0() throw()
00419         {
00420             SafeExecute(*this);
00421         }
00422
00423         void Execute()
00424         {
00425             (obj_.*memFun_)();
00426         }
00427
00428     protected:
00429         ObjScopeGuardImpl0(Obj& obj, MemFun memFun) : obj_(obj), memFun_(memFun)
00430         {}
00431
00432         Obj& obj_;
00433         MemFun memFun_;
00434     };
00435
00436     template <class Obj, typename MemFun>
00437     inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
00438     {
00439         return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
00440     }
00441
00442     template <typename Ret, class Obj1, class Obj2>
00443     inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 &obj)
00444     {
00445       return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(obj,memFun);
00446     }
00447
00448     template <typename Ret, class Obj1, class Obj2>
00449     inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 *obj)
00450     {
00451       return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(*obj,memFun);
00452     }
00453
00470
00471     template <class Obj, typename MemFun, typename P1>
00472     class ObjScopeGuardImpl1 : public ScopeGuardImplBase
00473     {
00474     public:
00475         static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
00476         {
00477             return ObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1);
00478         }
00479
00480         ~ObjScopeGuardImpl1() throw()
00481         {
00482             SafeExecute(*this);
00483         }
00484
00485         void Execute()
00486         {
00487             (obj_.*memFun_)(p1_);
00488         }
00489
00490     protected:
00491         ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) : obj_(obj), memFun_(memFun), p1_(p1)
00492         {}
00493
00494         Obj& obj_;
00495         MemFun memFun_;
00496         const P1 p1_;
00497     };
00498
00499     template <class Obj, typename MemFun, typename P1>
00500     inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
00501     {
00502         return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
00503     }
00504
00505     template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b>
00506     inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 &obj, P1b p1)
00507     {
00508       return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(obj,memFun,p1);
00509     }
00510
00511     template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b>
00512     inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 *obj, P1b p1)
00513     {
00514       return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(*obj,memFun,p1);
00515     }
00516
00533
00534     template <class Obj, typename MemFun, typename P1, typename P2>
00535     class ObjScopeGuardImpl2 : public ScopeGuardImplBase
00536     {
00537     public:
00538         static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
00539         {
00540             return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2);
00541         }
00542
00543         ~ObjScopeGuardImpl2() throw()
00544         {
00545             SafeExecute(*this);
00546         }
00547
00548         void Execute()
00549         {
00550             (obj_.*memFun_)(p1_, p2_);
00551         }
00552
00553     protected:
00554         ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2)
00555         {}
00556
00557         Obj& obj_;
00558         MemFun memFun_;
00559         const P1 p1_;
00560         const P2 p2_;
00561     };
00562
00563     template <class Obj, typename MemFun, typename P1, typename P2>
00564     inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
00565     {
00566         return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2);
00567     }
00568
00569     template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b>
00570     inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 &obj, P1b p1, P2b p2)
00571     {
00572       return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(obj,memFun,p1,p2);
00573     }
00574
00575     template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b>
00576     inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 *obj, P1b p1, P2b p2)
00577     {
00578       return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(*obj,memFun,p1,p2);
00579     }
00580
00597
00598     template < class Obj, typename MemFun, typename P1, typename P2, typename P3 >
00599     class ObjScopeGuardImpl3 : public ScopeGuardImplBase
00600     {
00601     public:
00602         static ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard(
00603             Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 )
00604         {
00605             return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >( obj, memFun, p1, p2, p3 );
00606         }
00607
00608         ~ObjScopeGuardImpl3() throw()
00609         {
00610             SafeExecute( *this );
00611         }
00612
00613         void Execute()
00614         {
00615             ( obj_.*memFun_ )( p1_, p2_, p3_ );
00616         }
00617
00618     protected:
00619         ObjScopeGuardImpl3( Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) :
00620              obj_( obj ), memFun_( memFun ), p1_( p1 ), p2_( p2 ), p3_( p3 )
00621         {}
00622
00623         Obj& obj_;
00624         MemFun memFun_;
00625         const P1 p1_;
00626         const P2 p2_;
00627         const P3 p3_;
00628     };
00629
00630     template < class Obj, typename MemFun, typename P1, typename P2, typename P3 >
00631     inline ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard(
00632         Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 )
00633     {
00634         return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >::MakeObjGuard(
00635             obj, memFun, p1, p2, p3 );
00636     }
00637
00638     template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b,
00639         typename P2a, typename P2b, typename P3a, typename P3b >
00640     inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
00641         MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 & obj, P1b p1, P2b p2, P3b p3 )
00642     {
00643       return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
00644           ::MakeObjGuard( obj, memFun, p1, p2, p3 );
00645     }
00646
00647     template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b,
00648         typename P2a, typename P2b, typename P3a, typename P3b >
00649     inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
00650         MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 * obj, P1b p1, P2b p2, P3b p3 )
00651     {
00652       return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
00653           ::MakeObjGuard( *obj, memFun, p1, p2, p3 );
00654     }
00655
00656 } // namespace Loki
00657
00658 #define LOKI_CONCATENATE_DIRECT(s1, s2)  s1##s2
00659 #define LOKI_CONCATENATE(s1, s2)         LOKI_CONCATENATE_DIRECT(s1, s2)
00660 #define LOKI_ANONYMOUS_VARIABLE(str)     LOKI_CONCATENATE(str, __LINE__)
00661
00662 #define LOKI_ON_BLOCK_EXIT      ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeGuard
00663 #define LOKI_ON_BLOCK_EXIT_OBJ  ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeObjGuard
00664
00665 #endif // end file guardian
00666
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Sequence.h Source File

Sequence.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2005 by Peter Kümmel
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012 #ifndef LOKI_SEQUENCE_INC_
00013 #define LOKI_SEQUENCE_INC_
00014
00015 // $Id: Sequence.h 768 2006-10-25 20:40:40Z syntheticpp $
00016
00017
00018 #include "Typelist.h"
00019
00020 namespace Loki
00021 {
00022
00023     template
00024     <
00025         class T01=NullType,class T02=NullType,class T03=NullType,class T04=NullType,class T05=NullType,
00026         class T06=NullType,class T07=NullType,class T08=NullType,class T09=NullType,class T10=NullType,
00027         class T11=NullType,class T12=NullType,class T13=NullType,class T14=NullType,class T15=NullType,
00028         class T16=NullType,class T17=NullType,class T18=NullType,class T19=NullType,class T20=NullType
00029     >
00030     struct Seq
00031     {
00032     private:
00033         typedef typename Seq<     T02, T03, T04, T05, T06, T07, T08, T09, T10,
00034                              T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>::Type
00035                          TailResult;
00036     public:
00037         typedef Typelist<T01, TailResult> Type;
00038     };
00039
00040     template<>
00041     struct Seq<>
00042     {
00043         typedef NullType Type;
00044     };
00045
00046 }   // namespace Loki
00047
00048 #endif // end file guardian
00049
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Singleton.cpp Source File

Singleton.cpp

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015
00016 // $Id: Singleton.cpp 756 2006-10-17 20:05:42Z syntheticpp $
00017
00018
00019 #include <loki/Singleton.h>
00020
00021
00022 #ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
00023 Loki::Private::TrackerArray* Loki::Private::pTrackerArray = 0;
00024 #else
00025 Loki::Private::TrackerArray Loki::Private::pTrackerArray = 0;
00026 unsigned int Loki::Private::elements = 0;
00027 #endif
00028
00030 // function AtExitFn
00031 // Ensures proper destruction of objects with longevity
00033
00034 #ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
00035
00036 void LOKI_C_CALLING_CONVENTION_QUALIFIER Loki::Private::AtExitFn()
00037 {
00038     assert(pTrackerArray!=0 && !pTrackerArray->empty());
00039
00040     // Pick the element at the top of the stack
00041     LifetimeTracker* pTop = pTrackerArray->back();
00042
00043     // Remove that object off the stack _before_ deleting pTop
00044     pTrackerArray->pop_back();
00045
00046     // Destroy the element
00047     delete pTop;
00048
00049     // Destroy stack when it's empty _after_ deleting pTop
00050     if(pTrackerArray->empty())
00051     {
00052         delete pTrackerArray;
00053         pTrackerArray = 0;
00054     }
00055 }
00056
00057 #else
00058
00059 void LOKI_C_CALLING_CONVENTION_QUALIFIER Loki::Private::AtExitFn()
00060 {
00061     assert(elements > 0 && pTrackerArray != 0);
00062     // Pick the element at the top of the stack
00063     LifetimeTracker* pTop = pTrackerArray[elements - 1];
00064     // Remove that object off the stack
00065     // Don't check errors - realloc with less memory
00066     //     can't fail
00067     pTrackerArray = static_cast<TrackerArray>(std::realloc(
00068         pTrackerArray, sizeof(*pTrackerArray) * --elements));
00069     // Destroy the element
00070     delete pTop;
00071 }
00072
00073 #endif
00074
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Singleton.h Source File

Singleton.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_SINGLETON_INC_
00016 #define LOKI_SINGLETON_INC_
00017
00018 // $Id: Singleton.h 747 2006-10-17 19:48:40Z syntheticpp $
00019
00020
00021 #include "LokiExport.h"
00022 #include "Threads.h"
00023 #include <algorithm>
00024 #include <stdexcept>
00025 #include <cassert>
00026 #include <cstdlib>
00027 #include <new>
00028 #include <vector>
00029 #include <list>
00030 #include <memory>
00031
00032 #ifdef _MSC_VER
00033 #define LOKI_C_CALLING_CONVENTION_QUALIFIER __cdecl
00034 #else
00035 #define LOKI_C_CALLING_CONVENTION_QUALIFIER
00036 #endif
00037
00050
00051
00052
00053 namespace Loki
00054 {
00055     typedef void (LOKI_C_CALLING_CONVENTION_QUALIFIER *atexit_pfn_t)();
00056
00057     namespace Private
00058     {
00059
00060 #ifndef LOKI_MAKE_DLL
00061         void LOKI_C_CALLING_CONVENTION_QUALIFIER AtExitFn(); // declaration needed below
00062 #else
00063         void LOKI_EXPORT AtExitFn();
00064 #endif
00065
00066         class LifetimeTracker;
00067
00068 #define LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
00069 #ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
00070
00071         // Helper data
00072         // std::list because of the inserts
00073         typedef std::list<LifetimeTracker*> TrackerArray;
00074         extern LOKI_EXPORT TrackerArray* pTrackerArray;
00075 #else
00076         // Helper data
00077         typedef LifetimeTracker** TrackerArray;
00078         extern TrackerArray pTrackerArray;
00079         extern unsigned int elements;
00080 #endif
00081
00083         // class LifetimeTracker
00084         // Helper class for SetLongevity
00086
00087         class LifetimeTracker
00088         {
00089         public:
00090             LifetimeTracker(unsigned int x) : longevity_(x)
00091             {}
00092
00093             virtual ~LifetimeTracker() = 0;
00094
00095             static bool Compare(const LifetimeTracker* lhs,
00096                 const LifetimeTracker* rhs)
00097             {
00098                 return lhs->longevity_ > rhs->longevity_;
00099             }
00100
00101         private:
00102             unsigned int longevity_;
00103         };
00104
00105         // Definition required
00106         inline LifetimeTracker::~LifetimeTracker() {}
00107
00108         // Helper destroyer function
00109         template <typename T>
00110         struct Deleter
00111         {
00112             typedef void (*Type)(T*);
00113             static void Delete(T* pObj)
00114             { delete pObj; }
00115         };
00116
00117         // Concrete lifetime tracker for objects of type T
00118         template <typename T, typename Destroyer>
00119         class ConcreteLifetimeTracker : public LifetimeTracker
00120         {
00121         public:
00122             ConcreteLifetimeTracker(T* p,unsigned int longevity, Destroyer d)
00123                 : LifetimeTracker(longevity)
00124                 , pTracked_(p)
00125                 , destroyer_(d)
00126             {}
00127
00128             ~ConcreteLifetimeTracker()
00129             { destroyer_(pTracked_); }
00130
00131         private:
00132             T* pTracked_;
00133             Destroyer destroyer_;
00134         };
00135
00136     } // namespace Private
00137
00144
00145 #ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
00146
00147     template <typename T, typename Destroyer>
00148     void SetLongevity(T* pDynObject, unsigned int longevity,
00149         Destroyer d)
00150     {
00151         using namespace Private;
00152
00153         // manage lifetime of stack manually
00154         if(pTrackerArray==0)
00155             pTrackerArray = new TrackerArray;
00156
00157         // automatically delete the ConcreteLifetimeTracker object when a exception is thrown
00158         std::auto_ptr<LifetimeTracker>
00159             p( new ConcreteLifetimeTracker<T, Destroyer>(pDynObject, longevity, d) );
00160
00161         // Find correct position
00162         TrackerArray::iterator pos = std::upper_bound(
00163             pTrackerArray->begin(),
00164             pTrackerArray->end(),
00165             p.get(),
00166             LifetimeTracker::Compare);
00167
00168         // Insert the pointer to the ConcreteLifetimeTracker object into the queue
00169         pTrackerArray->insert(pos, p.get());
00170
00171         // nothing has thrown: don't delete the ConcreteLifetimeTracker object
00172         p.release();
00173
00174         // Register a call to AtExitFn
00175         std::atexit(Private::AtExitFn);
00176     }
00177
00178 #else
00179
00180     template <typename T, typename Destroyer>
00181     void SetLongevity(T* pDynObject, unsigned int longevity,
00182         Destroyer d)
00183     {
00184         using namespace Private;
00185
00186         TrackerArray pNewArray = static_cast<TrackerArray>(
00187                 std::realloc(pTrackerArray,
00188                     sizeof(*pTrackerArray) * (elements + 1)));
00189         if (!pNewArray) throw std::bad_alloc();
00190
00191         // Delayed assignment for exception safety
00192         pTrackerArray = pNewArray;
00193
00194         LifetimeTracker* p = new ConcreteLifetimeTracker<T, Destroyer>(
00195             pDynObject, longevity, d);
00196
00197         // Insert a pointer to the object into the queue
00198         TrackerArray pos = std::upper_bound(
00199             pTrackerArray,
00200             pTrackerArray + elements,
00201             p,
00202             LifetimeTracker::Compare);
00203         std::copy_backward(
00204             pos,
00205             pTrackerArray + elements,
00206             pTrackerArray + elements + 1);
00207         *pos = p;
00208         ++elements;
00209
00210         // Register a call to AtExitFn
00211         std::atexit(Private::AtExitFn);
00212     }
00213
00214 #endif
00215
00216     template <typename T>
00217     void SetLongevity(T* pDynObject, unsigned int longevity,
00218         typename Private::Deleter<T>::Type d = Private::Deleter<T>::Delete)
00219     {
00220         SetLongevity<T, typename Private::Deleter<T>::Type>(pDynObject, longevity, d);
00221     }
00222
00230     template <class T> struct CreateUsingNew
00231     {
00232         static T* Create()
00233         { return new T; }
00234
00235         static void Destroy(T* p)
00236         { delete p; }
00237     };
00238
00247     template<template<class> class Alloc>
00248     struct CreateUsing
00249     {
00250         template <class T>
00251         struct Allocator
00252         {
00253             static Alloc<T> allocator;
00254
00255             static T* Create()
00256             {
00257                 return new (allocator.allocate(1)) T;
00258             }
00259
00260             static void Destroy(T* p)
00261             {
00262                 //allocator.destroy(p);
00263                 p->~T();
00264                 allocator.deallocate(p,1);
00265             }
00266         };
00267     };
00268
00277     template <class T> struct CreateUsingMalloc
00278     {
00279         static T* Create()
00280         {
00281             void* p = std::malloc(sizeof(T));
00282             if (!p) return 0;
00283             return new(p) T;
00284         }
00285
00286         static void Destroy(T* p)
00287         {
00288             p->~T();
00289             std::free(p);
00290         }
00291     };
00292
00293
00304     template <class T> struct CreateStatic
00305     {
00306
00307 #ifdef _MSC_VER
00308 #pragma warning( push )
00309 #pragma warning( disable : 4121 )
00310 // alignment of a member was sensitive to packing
00311 #endif // _MSC_VER
00312
00313         union MaxAlign
00314         {
00315             char t_[sizeof(T)];
00316             short int shortInt_;
00317             int int_;
00318             long int longInt_;
00319             float float_;
00320             double double_;
00321             long double longDouble_;
00322             struct Test;
00323             int Test::* pMember_;
00324             int (Test::*pMemberFn_)(int);
00325         };
00326
00327 #ifdef _MSC_VER
00328 #pragma warning( pop )
00329 #endif // _MSC_VER
00330
00331         static T* Create()
00332         {
00333             static MaxAlign staticMemory_;
00334             return new(&staticMemory_) T;
00335         }
00336
00337         static void Destroy(T* p)
00338         {
00339             p->~T();
00340         }
00341     };
00342
00351     template <class T>
00352     struct DefaultLifetime
00353     {
00354         static void ScheduleDestruction(T*, atexit_pfn_t pFun)
00355         { std::atexit(pFun); }
00356
00357         static void OnDeadReference()
00358         { throw std::logic_error("Dead Reference Detected"); }
00359     };
00360
00369     template <class T>
00370     class PhoenixSingleton
00371     {
00372     public:
00373         static void ScheduleDestruction(T*, atexit_pfn_t pFun)
00374         {
00375 #ifndef ATEXIT_FIXED
00376             if (!destroyedOnce_)
00377 #endif
00378                 std::atexit(pFun);
00379         }
00380
00381         static void OnDeadReference()
00382         {
00383 #ifndef ATEXIT_FIXED
00384             destroyedOnce_ = true;
00385 #endif
00386         }
00387
00388     private:
00389 #ifndef ATEXIT_FIXED
00390         static bool destroyedOnce_;
00391 #endif
00392     };
00393
00394 #ifndef ATEXIT_FIXED
00395     template <class T> bool PhoenixSingleton<T>::destroyedOnce_ = false;
00396 #endif
00397
00399     // Copyright (c) 2004 by Curtis Krauskopf - curtis@decompile.com
00416     template <class T>
00417     class DeletableSingleton
00418     {
00419     public:
00420
00421         static void ScheduleDestruction(T*, atexit_pfn_t pFun)
00422         {
00423             static bool firstPass = true;
00424             isDead = false;
00425             deleter = pFun;
00426             if (firstPass || needCallback)
00427             {
00428                 std::atexit(atexitCallback);
00429                 firstPass = false;
00430                 needCallback = false;
00431             }
00432         }
00433
00434         static void OnDeadReference()
00435         {
00436         }
00438         static void GracefulDelete()
00439         {
00440             if (isDead)
00441                 return;
00442             isDead = true;
00443             deleter();
00444         }
00445
00446     protected:
00447         static atexit_pfn_t deleter;
00448         static bool isDead;
00449         static bool needCallback;
00450
00451         static void atexitCallback()
00452         {
00453 #ifdef ATEXIT_FIXED
00454             needCallback = true;
00455 #else
00456             needCallback = false;
00457 #endif
00458             GracefulDelete();
00459         }
00460     };
00461
00462     template <class T>
00463     atexit_pfn_t DeletableSingleton<T>::deleter = 0;
00464
00465     template <class T>
00466     bool DeletableSingleton<T>::isDead = true;
00467
00468     template <class T>
00469     bool DeletableSingleton<T>::needCallback = true;
00470
00472     // class template Adapter
00473     // Helper for SingletonWithLongevity below
00475
00476     namespace Private
00477     {
00478         template <class T>
00479         struct Adapter
00480         {
00481             void operator()(T*) { return pFun_(); }
00482             atexit_pfn_t pFun_;
00483         };
00484     }
00485
00495     template <class T>
00496     class SingletonWithLongevity
00497     {
00498     public:
00499         static void ScheduleDestruction(T* pObj, atexit_pfn_t pFun)
00500         {
00501             Private::Adapter<T> adapter = { pFun };
00502             SetLongevity(pObj, GetLongevity(pObj), adapter);
00503         }
00504
00505         static void OnDeadReference()
00506         { throw std::logic_error("Dead Reference Detected"); }
00507     };
00508
00516     template <class T>
00517     struct NoDestroy
00518     {
00519         static void ScheduleDestruction(T*, atexit_pfn_t)
00520         {}
00521
00522         static void OnDeadReference()
00523         {}
00524     };
00525
00526
00537     namespace LongevityLifetime
00538     {
00549         template <unsigned int Longevity, class T>
00550         class SingletonFixedLongevity
00551         {
00552         public:
00553             virtual ~SingletonFixedLongevity() {}
00554
00555             static void ScheduleDestruction(T* pObj, atexit_pfn_t pFun)
00556             {
00557                 Private::Adapter<T> adapter = { pFun };
00558                 SetLongevity(pObj, Longevity , adapter);
00559             }
00560
00561             static void OnDeadReference()
00562             { throw std::logic_error("Dead Reference Detected"); }
00563         };
00564
00568         template <class T>
00569         struct DieLast  : SingletonFixedLongevity<0xFFFFFFFF ,T>
00570         {};
00571
00575         template <class T>
00576         struct DieDirectlyBeforeLast  : SingletonFixedLongevity<0xFFFFFFFF-1 ,T>
00577         {};
00578
00582         template <class T>
00583         struct DieFirst : SingletonFixedLongevity<0,T>
00584         {};
00585
00586     }//namespace LongevityLifetime
00587
00606     class FollowIntoDeath
00607     {
00608         template<class T>
00609         class Followers
00610         {
00611             typedef std::vector<atexit_pfn_t> Container;
00612             typedef typename Container::iterator iterator;
00613             static Container* followers_;
00614
00615         public:
00616             static void Init()
00617             {
00618                 static bool done = false;
00619                 if(!done)
00620                 {
00621                     followers_ = new Container;
00622                     done = true;
00623                 }
00624             }
00625
00626             static void AddFollower(atexit_pfn_t ae)
00627             {
00628                 Init();
00629                 followers_->push_back(ae);
00630             }
00631
00632             static void DestroyFollowers()
00633             {
00634                 Init();
00635                 for(iterator it = followers_->begin();it != followers_->end();++it)
00636                     (*it)();
00637                 delete followers_;
00638             }
00639         };
00640
00641     public:
00642
00646         template<template <class> class Lifetime>
00647         struct With
00648         {
00651             template<class Master>
00652             struct AsMasterLifetime
00653             {
00654                 static void ScheduleDestruction(Master* pObj, atexit_pfn_t pFun)
00655                 {
00656                     Followers<Master>::Init();
00657                     Lifetime<Master>::ScheduleDestruction(pObj, pFun);
00658
00659                     // use same policy for the followers and force a new
00660                     // template instantiation,  this adds a additional atexit entry
00661                     // does not work with SetLonlevity, but there you can control
00662                     // the lifetime with the GetLongevity function.
00663                     Lifetime<Followers<Master> >::ScheduleDestruction(0,Followers<Master>::DestroyFollowers);
00664                 }
00665
00666                 static void OnDeadReference()
00667                 {
00668                     throw std::logic_error("Dead Reference Detected");
00669                 }
00670             };
00671         };
00672
00676         template<class Master>
00677         struct AfterMaster
00678         {
00681             template<class F>
00682             struct IsDestroyed
00683             {
00684                 static void ScheduleDestruction(F*, atexit_pfn_t pFun)
00685                 {
00686                     Followers<Master>::AddFollower(pFun);
00687                 }
00688
00689                 static void OnDeadReference()
00690                 {
00691                     throw std::logic_error("Dead Reference Detected");
00692                 }
00693             };
00694         };
00695     };
00696
00697     template<class T>
00698     typename FollowIntoDeath::Followers<T>::Container*
00699     FollowIntoDeath::Followers<T>::followers_ = 0;
00700
00701
00702
00717     template
00718     <
00719         typename T,
00720         template <class> class CreationPolicy = CreateUsingNew,
00721         template <class> class LifetimePolicy = DefaultLifetime,
00722         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
00723         class MutexPolicy = LOKI_DEFAULT_MUTEX
00724     >
00725     class SingletonHolder
00726     {
00727     public:
00728
00730         typedef T ObjectType;
00731
00733         static T& Instance();
00734
00735     private:
00736         // Helpers
00737         static void MakeInstance();
00738         static void LOKI_C_CALLING_CONVENTION_QUALIFIER DestroySingleton();
00739
00740         // Protection
00741         SingletonHolder();
00742
00743         // Data
00744         typedef typename ThreadingModel<T*,MutexPolicy>::VolatileType PtrInstanceType;
00745         static PtrInstanceType pInstance_;
00746         static bool destroyed_;
00747     };
00748
00750     // SingletonHolder's data
00752
00753     template
00754     <
00755         class T,
00756         template <class> class C,
00757         template <class> class L,
00758         template <class, class> class M,
00759         class X
00760     >
00761     typename SingletonHolder<T, C, L, M, X>::PtrInstanceType
00762         SingletonHolder<T, C, L, M, X>::pInstance_;
00763
00764     template
00765     <
00766         class T,
00767         template <class> class C,
00768         template <class> class L,
00769         template <class, class> class M,
00770         class X
00771     >
00772     bool SingletonHolder<T, C, L, M, X>::destroyed_;
00773
00775     // SingletonHolder::Instance
00777
00778     template
00779     <
00780         class T,
00781         template <class> class CreationPolicy,
00782         template <class> class LifetimePolicy,
00783         template <class, class> class ThreadingModel,
00784         class MutexPolicy
00785     >
00786     inline T& SingletonHolder<T, CreationPolicy,
00787         LifetimePolicy, ThreadingModel, MutexPolicy>::Instance()
00788     {
00789         if (!pInstance_)
00790         {
00791             MakeInstance();
00792         }
00793         return *pInstance_;
00794     }
00795
00797     // SingletonHolder::MakeInstance (helper for Instance)
00799
00800     template
00801     <
00802         class T,
00803         template <class> class CreationPolicy,
00804         template <class> class LifetimePolicy,
00805         template <class, class> class ThreadingModel,
00806         class MutexPolicy
00807     >
00808     void SingletonHolder<T, CreationPolicy,
00809         LifetimePolicy, ThreadingModel, MutexPolicy>::MakeInstance()
00810     {
00811         typename ThreadingModel<SingletonHolder,MutexPolicy>::Lock guard;
00812         (void)guard;
00813
00814         if (!pInstance_)
00815         {
00816             if (destroyed_)
00817             {
00818                 destroyed_ = false;
00819                 LifetimePolicy<T>::OnDeadReference();
00820             }
00821             pInstance_ = CreationPolicy<T>::Create();
00822             LifetimePolicy<T>::ScheduleDestruction(pInstance_,
00823                 &DestroySingleton);
00824         }
00825     }
00826
00827     template
00828     <
00829         class T,
00830         template <class> class CreationPolicy,
00831         template <class> class L,
00832         template <class, class> class M,
00833         class X
00834     >
00835     void LOKI_C_CALLING_CONVENTION_QUALIFIER
00836     SingletonHolder<T, CreationPolicy, L, M, X>::DestroySingleton()
00837     {
00838         assert(!destroyed_);
00839         CreationPolicy<T>::Destroy(pInstance_);
00840         pInstance_ = 0;
00841         destroyed_ = true;
00842     }
00843
00844
00858
00859 #ifndef LOKI_SINGLETON_EXPORT
00860 #define LOKI_SINGLETON_EXPORT
00861 #endif
00862
00863     template<class T>
00864     class LOKI_SINGLETON_EXPORT Singleton
00865     {
00866     public:
00867         static T& Instance();
00868     };
00869
00870 } // namespace Loki
00871
00872
00876
00877 #define LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER)                     \
00878 namespace Loki                                                          \
00879 {                                                                        \
00880     template<>                                                          \
00881     SHOLDER::ObjectType&  Singleton<SHOLDER::ObjectType>::Instance()    \
00882     {                                                                   \
00883         return SHOLDER::Instance();                                     \
00884     }                                                                    \
00885 }
00886
00887
00888 #endif // end file guardian
00889
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: SmallObj.cpp Source File

SmallObj.cpp

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above  copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015
00016 // $Id: SmallObj.cpp 756 2006-10-17 20:05:42Z syntheticpp $
00017
00018
00019 #include <loki/SmallObj.h>
00020
00021 #include <cassert>
00022 #include <vector>
00023 #include <bitset>
00024
00025 //#define DO_EXTRA_LOKI_TESTS
00026 //#define USE_NEW_TO_ALLOCATE
00027
00028 #ifdef DO_EXTRA_LOKI_TESTS
00029     #include <iostream>
00030 #endif
00031
00032 namespace Loki
00033 {
00034
00068     class Chunk
00069     {
00070     private:
00071         friend class FixedAllocator;
00072
00078         bool Init( std::size_t blockSize, unsigned char blocks );
00079
00086         void * Allocate( std::size_t blockSize );
00087
00096         void Deallocate( void * p, std::size_t blockSize );
00097
00103         void Reset( std::size_t blockSize, unsigned char blocks );
00104
00106         void Release();
00107
00117         bool IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
00118             bool checkIndexes ) const;
00119
00126         bool IsBlockAvailable( void * p, unsigned char numBlocks,
00127             std::size_t blockSize ) const;
00128
00130         inline bool HasBlock( void * p, std::size_t chunkLength ) const
00131         {
00132             unsigned char * pc = static_cast< unsigned char * >( p );
00133             return ( pData_ <= pc ) && ( pc < pData_ + chunkLength );
00134         }
00135
00136         inline bool HasAvailable( unsigned char numBlocks ) const
00137         { return ( blocksAvailable_ == numBlocks ); }
00138
00139         inline bool IsFilled( void ) const
00140         { return ( 0 == blocksAvailable_ ); }
00141
00143         unsigned char * pData_;
00145         unsigned char firstAvailableBlock_;
00147         unsigned char blocksAvailable_;
00148     };
00149
00168     class FixedAllocator
00169     {
00170     private:
00171
00176         void DoDeallocate( void * p );
00177
00183         bool MakeNewChunk( void );
00184
00197         Chunk * VicinityFind( void * p ) const;
00198
00200         FixedAllocator(const FixedAllocator&);
00202         FixedAllocator& operator=(const FixedAllocator&);
00203
00205         typedef std::vector< Chunk > Chunks;
00207         typedef Chunks::iterator ChunkIter;
00209         typedef Chunks::const_iterator ChunkCIter;
00210
00212         static unsigned char MinObjectsPerChunk_;
00213
00215         static unsigned char MaxObjectsPerChunk_;
00216
00218         std::size_t blockSize_;
00220         unsigned char numBlocks_;
00221
00223         Chunks chunks_;
00225         Chunk * allocChunk_;
00227         Chunk * deallocChunk_;
00229         Chunk * emptyChunk_;
00230
00231     public:
00233         FixedAllocator();
00234
00236         ~FixedAllocator();
00237
00239         void Initialize( std::size_t blockSize, std::size_t pageSize );
00240
00244         void * Allocate( void );
00245
00251         bool Deallocate( void * p, Chunk * hint );
00252
00254         inline std::size_t BlockSize() const { return blockSize_; }
00255
00260         bool TrimEmptyChunk( void );
00261
00267         bool TrimChunkList( void );
00268
00272         std::size_t CountEmptyChunks( void ) const;
00273
00280         bool IsCorrupt( void ) const;
00281
00286         const Chunk * HasBlock( void * p ) const;
00287         inline Chunk * HasBlock( void * p )
00288         {
00289             return const_cast< Chunk * >(
00290                 const_cast< const FixedAllocator * >( this )->HasBlock( p ) );
00291         }
00292
00293     };
00294
00295     unsigned char FixedAllocator::MinObjectsPerChunk_ = 8;
00296     unsigned char FixedAllocator::MaxObjectsPerChunk_ = UCHAR_MAX;
00297
00298 // Chunk::Init ----------------------------------------------------------------
00299
00300 bool Chunk::Init( std::size_t blockSize, unsigned char blocks )
00301 {
00302     assert(blockSize > 0);
00303     assert(blocks > 0);
00304     // Overflow check
00305     const std::size_t allocSize = blockSize * blocks;
00306     assert( allocSize / blockSize == blocks);
00307
00308 #ifdef USE_NEW_TO_ALLOCATE
00309     // If this new operator fails, it will throw, and the exception will get
00310     // caught one layer up.
00311     pData_ = static_cast< unsigned char * >( ::operator new ( allocSize ) );
00312 #else
00313     // malloc can't throw, so its only way to indicate an error is to return
00314     // a NULL pointer, so we have to check for that.
00315     pData_ = static_cast< unsigned char * >( ::std::malloc( allocSize ) );
00316     if ( NULL == pData_ ) return false;
00317 #endif
00318
00319     Reset( blockSize, blocks );
00320     return true;
00321 }
00322
00323 // Chunk::Reset ---------------------------------------------------------------
00324
00325 void Chunk::Reset(std::size_t blockSize, unsigned char blocks)
00326 {
00327     assert(blockSize > 0);
00328     assert(blocks > 0);
00329     // Overflow check
00330     assert((blockSize * blocks) / blockSize == blocks);
00331
00332     firstAvailableBlock_ = 0;
00333     blocksAvailable_ = blocks;
00334
00335     unsigned char i = 0;
00336     for ( unsigned char * p = pData_; i != blocks; p += blockSize )
00337     {
00338         *p = ++i;
00339     }
00340 }
00341
00342 // Chunk::Release -------------------------------------------------------------
00343
00344 void Chunk::Release()
00345 {
00346     assert( NULL != pData_ );
00347 #ifdef USE_NEW_TO_ALLOCATE
00348     ::operator delete ( pData_ );
00349 #else
00350     ::std::free( static_cast< void * >( pData_ ) );
00351 #endif
00352 }
00353
00354 // Chunk::Allocate ------------------------------------------------------------
00355
00356 void* Chunk::Allocate(std::size_t blockSize)
00357 {
00358     if ( IsFilled() ) return NULL;
00359
00360     assert((firstAvailableBlock_ * blockSize) / blockSize ==
00361         firstAvailableBlock_);
00362     unsigned char * pResult = pData_ + (firstAvailableBlock_ * blockSize);
00363     firstAvailableBlock_ = *pResult;
00364     --blocksAvailable_;
00365
00366     return pResult;
00367 }
00368
00369 // Chunk::Deallocate ----------------------------------------------------------
00370
00371 void Chunk::Deallocate(void* p, std::size_t blockSize)
00372 {
00373     assert(p >= pData_);
00374
00375     unsigned char* toRelease = static_cast<unsigned char*>(p);
00376     // Alignment check
00377     assert((toRelease - pData_) % blockSize == 0);
00378     unsigned char index = static_cast< unsigned char >(
00379         ( toRelease - pData_ ) / blockSize);
00380
00381 #if defined(DEBUG) || defined(_DEBUG)
00382     // Check if block was already deleted.  Attempting to delete the same
00383     // block more than once causes Chunk's linked-list of stealth indexes to
00384     // become corrupt.  And causes count of blocksAvailable_ to be wrong.
00385     if ( 0 < blocksAvailable_ )
00386         assert( firstAvailableBlock_ != index );
00387 #endif
00388
00389     *toRelease = firstAvailableBlock_;
00390     firstAvailableBlock_ = index;
00391     // Truncation check
00392     assert(firstAvailableBlock_ == (toRelease - pData_) / blockSize);
00393
00394     ++blocksAvailable_;
00395 }
00396
00397 // Chunk::IsCorrupt -----------------------------------------------------------
00398
00399 bool Chunk::IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
00400     bool checkIndexes ) const
00401 {
00402
00403     if ( numBlocks < blocksAvailable_ )
00404     {
00405         // Contents at this Chunk corrupted.  This might mean something has
00406         // overwritten memory owned by the Chunks container.
00407         assert( false );
00408         return true;
00409     }
00410     if ( IsFilled() )
00411         // Useless to do further corruption checks if all blocks allocated.
00412         return false;
00413     unsigned char index = firstAvailableBlock_;
00414     if ( numBlocks <= index )
00415     {
00416         // Contents at this Chunk corrupted.  This might mean something has
00417         // overwritten memory owned by the Chunks container.
00418         assert( false );
00419         return true;
00420     }
00421     if ( !checkIndexes )
00422         // Caller chose to skip more complex corruption tests.
00423         return false;
00424
00425     /* If the bit at index was set in foundBlocks, then the stealth index was
00426      found on the linked-list.
00427      */
00428     std::bitset< UCHAR_MAX > foundBlocks;
00429     unsigned char * nextBlock = NULL;
00430
00431     /* The loop goes along singly linked-list of stealth indexes and makes sure
00432      that each index is within bounds (0 <= index < numBlocks) and that the
00433      index was not already found while traversing the linked-list.  The linked-
00434      list should have exactly blocksAvailable_ nodes, so the for loop will not
00435      check more than blocksAvailable_.  This loop can't check inside allocated
00436      blocks for corruption since such blocks are not within the linked-list.
00437      Contents of allocated blocks are not changed by Chunk.
00438
00439      Here are the types of corrupted link-lists which can be verified.  The
00440      corrupt index is shown with asterisks in each example.
00441
00442      Type 1: Index is too big.
00443       numBlocks == 64
00444       blocksAvailable_ == 7
00445       firstAvailableBlock_ -> 17 -> 29 -> *101*
00446       There should be no indexes which are equal to or larger than the total
00447       number of blocks.  Such an index would refer to a block beyond the
00448       Chunk's allocated domain.
00449
00450      Type 2: Index is repeated.
00451       numBlocks == 64
00452       blocksAvailable_ == 5
00453       firstAvailableBlock_ -> 17 -> 29 -> 53 -> *17* -> 29 -> 53 ...
00454       No index should be repeated within the linked-list since that would
00455       indicate the presence of a loop in the linked-list.
00456      */
00457     for ( unsigned char cc = 0; ; )
00458     {
00459         nextBlock = pData_ + ( index * blockSize );
00460         foundBlocks.set( index, true );
00461         ++cc;
00462         if ( cc >= blocksAvailable_ )
00463             // Successfully counted off number of nodes in linked-list.
00464             break;
00465         index = *nextBlock;
00466         if ( numBlocks <= index )
00467         {
00468             /* This catches Type 1 corruptions as shown in above comments.
00469              This implies that a block was corrupted due to a stray pointer
00470              or an operation on a nearby block overran the size of the block.
00471              */
00472             assert( false );
00473             return true;
00474         }
00475         if ( foundBlocks.test( index ) )
00476         {
00477             /* This catches Type 2 corruptions as shown in above comments.
00478              This implies that a block was corrupted due to a stray pointer
00479              or an operation on a nearby block overran the size of the block.
00480              Or perhaps the program tried to delete a block more than once.
00481              */
00482             assert( false );
00483             return true;
00484         }
00485     }
00486     if ( foundBlocks.count() != blocksAvailable_ )
00487     {
00488         /* This implies that the singly-linked-list of stealth indexes was
00489          corrupted.  Ideally, this should have been detected within the loop.
00490          */
00491         assert( false );
00492         return true;
00493     }
00494
00495     return false;
00496 }
00497
00498 // Chunk::IsBlockAvailable ----------------------------------------------------
00499
00500 bool Chunk::IsBlockAvailable( void * p, unsigned char numBlocks,
00501     std::size_t blockSize ) const
00502 {
00503     (void) numBlocks;
00504
00505     if ( IsFilled() )
00506         return false;
00507
00508     unsigned char * place = static_cast< unsigned char * >( p );
00509     // Alignment check
00510     assert( ( place - pData_ ) % blockSize == 0 );
00511     unsigned char blockIndex = static_cast< unsigned char >(
00512         ( place - pData_ ) / blockSize );
00513
00514     unsigned char index = firstAvailableBlock_;
00515     assert( numBlocks > index );
00516     if ( index == blockIndex )
00517         return true;
00518
00519     /* If the bit at index was set in foundBlocks, then the stealth index was
00520      found on the linked-list.
00521      */
00522     std::bitset< UCHAR_MAX > foundBlocks;
00523     unsigned char * nextBlock = NULL;
00524     for ( unsigned char cc = 0; ; )
00525     {
00526         nextBlock = pData_ + ( index * blockSize );
00527         foundBlocks.set( index, true );
00528         ++cc;
00529         if ( cc >= blocksAvailable_ )
00530             // Successfully counted off number of nodes in linked-list.
00531             break;
00532         index = *nextBlock;
00533         if ( index == blockIndex )
00534             return true;
00535         assert( numBlocks > index );
00536         assert( !foundBlocks.test( index ) );
00537     }
00538
00539     return false;
00540 }
00541
00542 // FixedAllocator::FixedAllocator ---------------------------------------------
00543
00544 FixedAllocator::FixedAllocator()
00545     : blockSize_( 0 )
00546     , numBlocks_( 0 )
00547     , chunks_( 0 )
00548     , allocChunk_( NULL )
00549     , deallocChunk_( NULL )
00550     , emptyChunk_( NULL )
00551 {
00552 }
00553
00554 // FixedAllocator::~FixedAllocator --------------------------------------------
00555
00556 FixedAllocator::~FixedAllocator()
00557 {
00558 #ifdef DO_EXTRA_LOKI_TESTS
00559     TrimEmptyChunk();
00560     assert( chunks_.empty() && "Memory leak detected!" );
00561 #endif
00562     for ( ChunkIter i( chunks_.begin() ); i != chunks_.end(); ++i )
00563        i->Release();
00564 }
00565
00566 // FixedAllocator::Initialize -------------------------------------------------
00567
00568 void FixedAllocator::Initialize( std::size_t blockSize, std::size_t pageSize )
00569 {
00570     assert( blockSize > 0 );
00571     assert( pageSize >= blockSize );
00572     blockSize_ = blockSize;
00573
00574     std::size_t numBlocks = pageSize / blockSize;
00575     if ( numBlocks > MaxObjectsPerChunk_ ) numBlocks = MaxObjectsPerChunk_;
00576     else if ( numBlocks < MinObjectsPerChunk_ ) numBlocks = MinObjectsPerChunk_;
00577
00578     numBlocks_ = static_cast<unsigned char>(numBlocks);
00579     assert(numBlocks_ == numBlocks);
00580 }
00581
00582 // FixedAllocator::CountEmptyChunks -------------------------------------------
00583
00584 std::size_t FixedAllocator::CountEmptyChunks( void ) const
00585 {
00586 #ifdef DO_EXTRA_LOKI_TESTS
00587     // This code is only used for specialized tests of the allocator.
00588     // It is #ifdef-ed so that its O(C) complexity does not overwhelm the
00589     // functions which call it.
00590     std::size_t count = 0;
00591     for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it )
00592     {
00593         const Chunk & chunk = *it;
00594         if ( chunk.HasAvailable( numBlocks_ ) )
00595             ++count;
00596     }
00597     return count;
00598 #else
00599     return ( NULL == emptyChunk_ ) ? 0 : 1;
00600 #endif
00601 }
00602
00603 // FixedAllocator::IsCorrupt --------------------------------------------------
00604
00605 bool FixedAllocator::IsCorrupt( void ) const
00606 {
00607     const bool isEmpty = chunks_.empty();
00608     ChunkCIter start( chunks_.begin() );
00609     ChunkCIter last( chunks_.end() );
00610     const size_t emptyChunkCount = CountEmptyChunks();
00611
00612     if ( isEmpty )
00613     {
00614         if ( start != last )
00615         {
00616             assert( false );
00617             return true;
00618         }
00619         if ( 0 < emptyChunkCount )
00620         {
00621             assert( false );
00622             return true;
00623         }
00624         if ( NULL != deallocChunk_ )
00625         {
00626             assert( false );
00627             return true;
00628         }
00629         if ( NULL != allocChunk_ )
00630         {
00631             assert( false );
00632             return true;
00633         }
00634         if ( NULL != emptyChunk_ )
00635         {
00636             assert( false );
00637             return true;
00638         }
00639     }
00640
00641     else
00642     {
00643         const Chunk * front = &chunks_.front();
00644         const Chunk * back  = &chunks_.back();
00645         if ( start >= last )
00646         {
00647             assert( false );
00648             return true;
00649         }
00650         if ( back < deallocChunk_ )
00651         {
00652             assert( false );
00653             return true;
00654         }
00655         if ( back < allocChunk_ )
00656         {
00657             assert( false );
00658             return true;
00659         }
00660         if ( front > deallocChunk_ )
00661         {
00662             assert( false );
00663             return true;
00664         }
00665         if ( front > allocChunk_ )
00666         {
00667             assert( false );
00668             return true;
00669         }
00670
00671         switch ( emptyChunkCount )
00672         {
00673             case 0:
00674                 if ( emptyChunk_ != NULL )
00675                 {
00676                     assert( false );
00677                     return true;
00678                 }
00679                 break;
00680             case 1:
00681                 if ( emptyChunk_ == NULL )
00682                 {
00683                     assert( false );
00684                     return true;
00685                 }
00686                 if ( back < emptyChunk_ )
00687                 {
00688                     assert( false );
00689                     return true;
00690                 }
00691                 if ( front > emptyChunk_ )
00692                 {
00693                     assert( false );
00694                     return true;
00695                 }
00696                 if ( !emptyChunk_->HasAvailable( numBlocks_ ) )
00697                 {
00698                     // This may imply somebody tried to delete a block twice.
00699                     assert( false );
00700                     return true;
00701                 }
00702                 break;
00703             default:
00704                 assert( false );
00705                 return true;
00706         }
00707         for ( ChunkCIter it( start ); it != last; ++it )
00708         {
00709             const Chunk & chunk = *it;
00710             if ( chunk.IsCorrupt( numBlocks_, blockSize_, true ) )
00711                 return true;
00712         }
00713     }
00714
00715     return false;
00716 }
00717
00718 // FixedAllocator::HasBlock ---------------------------------------------------
00719
00720 const Chunk * FixedAllocator::HasBlock( void * p ) const
00721 {
00722     const std::size_t chunkLength = numBlocks_ * blockSize_;
00723     for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it )
00724     {
00725         const Chunk & chunk = *it;
00726         if ( chunk.HasBlock( p, chunkLength ) )
00727             return &chunk;
00728     }
00729     return NULL;
00730 }
00731
00732 // FixedAllocator::TrimEmptyChunk ---------------------------------------------
00733
00734 bool FixedAllocator::TrimEmptyChunk( void )
00735 {
00736     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
00737     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
00738     if ( NULL == emptyChunk_ ) return false;
00739
00740     // If emptyChunk_ points to valid Chunk, then chunk list is not empty.
00741     assert( !chunks_.empty() );
00742     // And there should be exactly 1 empty Chunk.
00743     assert( 1 == CountEmptyChunks() );
00744
00745     Chunk * lastChunk = &chunks_.back();
00746     if ( lastChunk != emptyChunk_ )
00747         std::swap( *emptyChunk_, *lastChunk );
00748     assert( lastChunk->HasAvailable( numBlocks_ ) );
00749     lastChunk->Release();
00750     chunks_.pop_back();
00751
00752     if ( chunks_.empty() )
00753     {
00754         allocChunk_ = NULL;
00755         deallocChunk_ = NULL;
00756     }
00757     else
00758     {
00759         if ( deallocChunk_ == emptyChunk_ )
00760         {
00761             deallocChunk_ = &chunks_.front();
00762             assert( deallocChunk_->blocksAvailable_ < numBlocks_ );
00763         }
00764         if ( allocChunk_ == emptyChunk_ )
00765         {
00766             allocChunk_ = &chunks_.back();
00767             assert( allocChunk_->blocksAvailable_ < numBlocks_ );
00768         }
00769     }
00770
00771     emptyChunk_ = NULL;
00772     assert( 0 == CountEmptyChunks() );
00773
00774     return true;
00775 }
00776
00777 // FixedAllocator::TrimChunkList ----------------------------------------------
00778
00779 bool FixedAllocator::TrimChunkList( void )
00780 {
00781     if ( chunks_.empty() )
00782     {
00783         assert( NULL == allocChunk_ );
00784         assert( NULL == deallocChunk_ );
00785     }
00786
00787     if ( chunks_.size() == chunks_.capacity() )
00788         return false;
00789     // Use the "make-a-temp-and-swap" trick to remove excess capacity.
00790     Chunks( chunks_ ).swap( chunks_ );
00791
00792     return true;
00793 }
00794
00795 // FixedAllocator::MakeNewChunk -----------------------------------------------
00796
00797 bool FixedAllocator::MakeNewChunk( void )
00798 {
00799     bool allocated = false;
00800     try
00801     {
00802         std::size_t size = chunks_.size();
00803         // Calling chunks_.reserve *before* creating and initializing the new
00804         // Chunk means that nothing is leaked by this function in case an
00805         // exception is thrown from reserve.
00806         if ( chunks_.capacity() == size )
00807         {
00808             if ( 0 == size ) size = 4;
00809             chunks_.reserve( size * 2 );
00810         }
00811         Chunk newChunk;
00812         allocated = newChunk.Init( blockSize_, numBlocks_ );
00813         if ( allocated )
00814             chunks_.push_back( newChunk );
00815     }
00816     catch ( ... )
00817     {
00818         allocated = false;
00819     }
00820     if ( !allocated ) return false;
00821
00822     allocChunk_ = &chunks_.back();
00823     deallocChunk_ = &chunks_.front();
00824     return true;
00825 }
00826
00827 // FixedAllocator::Allocate ---------------------------------------------------
00828
00829 void * FixedAllocator::Allocate( void )
00830 {
00831     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
00832     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
00833     assert( CountEmptyChunks() < 2 );
00834
00835     if ( ( NULL == allocChunk_ ) || allocChunk_->IsFilled() )
00836     {
00837         if ( NULL != emptyChunk_ )
00838         {
00839             allocChunk_ = emptyChunk_;
00840             emptyChunk_ = NULL;
00841         }
00842         else
00843         {
00844             for ( ChunkIter i( chunks_.begin() ); ; ++i )
00845             {
00846                 if ( chunks_.end() == i )
00847                 {
00848                     if ( !MakeNewChunk() )
00849                         return NULL;
00850                     break;
00851                 }
00852                 if ( !i->IsFilled() )
00853                 {
00854                     allocChunk_ = &*i;
00855                     break;
00856                 }
00857             }
00858         }
00859     }
00860     else if ( allocChunk_ == emptyChunk_)
00861         // detach emptyChunk_ from allocChunk_, because after
00862         // calling allocChunk_->Allocate(blockSize_); the chunk
00863         // is no longer empty.
00864         emptyChunk_ = NULL;
00865
00866     assert( allocChunk_ != NULL );
00867     assert( !allocChunk_->IsFilled() );
00868     void * place = allocChunk_->Allocate( blockSize_ );
00869
00870     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
00871     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
00872     assert( CountEmptyChunks() < 2 );
00873
00874     return place;
00875 }
00876
00877 // FixedAllocator::Deallocate -------------------------------------------------
00878
00879 bool FixedAllocator::Deallocate( void * p, Chunk * hint )
00880 {
00881     assert(!chunks_.empty());
00882     assert(&chunks_.front() <= deallocChunk_);
00883     assert(&chunks_.back() >= deallocChunk_);
00884     assert( &chunks_.front() <= allocChunk_ );
00885     assert( &chunks_.back() >= allocChunk_ );
00886     assert( CountEmptyChunks() < 2 );
00887
00888     Chunk * foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint;
00889     if ( NULL == foundChunk )
00890         return false;
00891
00892     assert( foundChunk->HasBlock( p, numBlocks_ * blockSize_ ) );
00893 #ifdef LOKI_CHECK_FOR_CORRUPTION
00894     if ( foundChunk->IsCorrupt( numBlocks_, blockSize_, true ) )
00895     {
00896         assert( false );
00897         return false;
00898     }
00899     if ( foundChunk->IsBlockAvailable( p, numBlocks_, blockSize_ ) )
00900     {
00901         assert( false );
00902         return false;
00903     }
00904 #endif
00905     deallocChunk_ = foundChunk;
00906     DoDeallocate(p);
00907     assert( CountEmptyChunks() < 2 );
00908
00909     return true;
00910 }
00911
00912 // FixedAllocator::VicinityFind -----------------------------------------------
00913
00914 Chunk * FixedAllocator::VicinityFind( void * p ) const
00915 {
00916     if ( chunks_.empty() ) return NULL;
00917     assert(deallocChunk_);
00918
00919     const std::size_t chunkLength = numBlocks_ * blockSize_;
00920     Chunk * lo = deallocChunk_;
00921     Chunk * hi = deallocChunk_ + 1;
00922     const Chunk * loBound = &chunks_.front();
00923     const Chunk * hiBound = &chunks_.back() + 1;
00924
00925     // Special case: deallocChunk_ is the last in the array
00926     if (hi == hiBound) hi = NULL;
00927
00928     for (;;)
00929     {
00930         if (lo)
00931         {
00932             if ( lo->HasBlock( p, chunkLength ) ) return lo;
00933             if ( lo == loBound )
00934             {
00935                 lo = NULL;
00936                 if ( NULL == hi ) break;
00937             }
00938             else --lo;
00939         }
00940
00941         if (hi)
00942         {
00943             if ( hi->HasBlock( p, chunkLength ) ) return hi;
00944             if ( ++hi == hiBound )
00945             {
00946                 hi = NULL;
00947                 if ( NULL == lo ) break;
00948             }
00949         }
00950     }
00951
00952     return NULL;
00953 }
00954
00955 // FixedAllocator::DoDeallocate -----------------------------------------------
00956
00957 void FixedAllocator::DoDeallocate(void* p)
00958 {
00959     // Show that deallocChunk_ really owns the block at address p.
00960     assert( deallocChunk_->HasBlock( p, numBlocks_ * blockSize_ ) );
00961     // Either of the next two assertions may fail if somebody tries to
00962     // delete the same block twice.
00963     assert( emptyChunk_ != deallocChunk_ );
00964     assert( !deallocChunk_->HasAvailable( numBlocks_ ) );
00965     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
00966     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
00967
00968     // call into the chunk, will adjust the inner list but won't release memory
00969     deallocChunk_->Deallocate(p, blockSize_);
00970
00971     if ( deallocChunk_->HasAvailable( numBlocks_ ) )
00972     {
00973         assert( emptyChunk_ != deallocChunk_ );
00974         // deallocChunk_ is empty, but a Chunk is only released if there are 2
00975         // empty chunks.  Since emptyChunk_ may only point to a previously
00976         // cleared Chunk, if it points to something else besides deallocChunk_,
00977         // then FixedAllocator currently has 2 empty Chunks.
00978         if ( NULL != emptyChunk_ )
00979         {
00980             // If last Chunk is empty, just change what deallocChunk_
00981             // points to, and release the last.  Otherwise, swap an empty
00982             // Chunk with the last, and then release it.
00983             Chunk * lastChunk = &chunks_.back();
00984             if ( lastChunk == deallocChunk_ )
00985                 deallocChunk_ = emptyChunk_;
00986             else if ( lastChunk != emptyChunk_ )
00987                 std::swap( *emptyChunk_, *lastChunk );
00988             assert( lastChunk->HasAvailable( numBlocks_ ) );
00989             lastChunk->Release();
00990             chunks_.pop_back();
00991             if ( ( allocChunk_ == lastChunk ) || allocChunk_->IsFilled() )
00992                 allocChunk_ = deallocChunk_;
00993         }
00994         emptyChunk_ = deallocChunk_;
00995     }
00996
00997     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
00998     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
00999 }
01000
01001 // GetOffset ------------------------------------------------------------------
01004 inline std::size_t GetOffset( std::size_t numBytes, std::size_t alignment )
01005 {
01006     const std::size_t alignExtra = alignment-1;
01007     return ( numBytes + alignExtra ) / alignment;
01008 }
01009
01010 // DefaultAllocator -----------------------------------------------------------
01019 void * DefaultAllocator( std::size_t numBytes, bool doThrow )
01020 {
01021 #ifdef USE_NEW_TO_ALLOCATE
01022     return doThrow ? ::operator new( numBytes ) :
01023         ::operator new( numBytes, std::nothrow_t() );
01024 #else
01025     void * p = ::std::malloc( numBytes );
01026     if ( doThrow && ( NULL == p ) )
01027         throw std::bad_alloc();
01028     return p;
01029 #endif
01030 }
01031
01032 // DefaultDeallocator ---------------------------------------------------------
01040 void DefaultDeallocator( void * p )
01041 {
01042 #ifdef USE_NEW_TO_ALLOCATE
01043     ::operator delete( p );
01044 #else
01045     ::std::free( p );
01046 #endif
01047 }
01048
01049 // SmallObjAllocator::SmallObjAllocator ---------------------------------------
01050
01051 SmallObjAllocator::SmallObjAllocator( std::size_t pageSize,
01052     std::size_t maxObjectSize, std::size_t objectAlignSize ) :
01053     pool_( NULL ),
01054     maxSmallObjectSize_( maxObjectSize ),
01055     objectAlignSize_( objectAlignSize )
01056 {
01057 #ifdef DO_EXTRA_LOKI_TESTS
01058     std::cout << "SmallObjAllocator " << this << std::endl;
01059 #endif
01060     assert( 0 != objectAlignSize );
01061     const std::size_t allocCount = GetOffset( maxObjectSize, objectAlignSize );
01062     pool_ = new FixedAllocator[ allocCount ];
01063     for ( std::size_t i = 0; i < allocCount; ++i )
01064         pool_[ i ].Initialize( ( i+1 ) * objectAlignSize, pageSize );
01065 }
01066
01067 // SmallObjAllocator::~SmallObjAllocator --------------------------------------
01068
01069 SmallObjAllocator::~SmallObjAllocator( void )
01070 {
01071 #ifdef DO_EXTRA_LOKI_TESTS
01072     std::cout << "~SmallObjAllocator " << this << std::endl;
01073 #endif
01074     delete [] pool_;
01075 }
01076
01077 // SmallObjAllocator::TrimExcessMemory ----------------------------------------
01078
01079 bool SmallObjAllocator::TrimExcessMemory( void )
01080 {
01081     bool found = false;
01082     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
01083     std::size_t i = 0;
01084     for ( ; i < allocCount; ++i )
01085     {
01086         if ( pool_[ i ].TrimEmptyChunk() )
01087             found = true;
01088     }
01089     for ( i = 0; i < allocCount; ++i )
01090     {
01091         if ( pool_[ i ].TrimChunkList() )
01092             found = true;
01093     }
01094
01095     return found;
01096 }
01097
01098 // SmallObjAllocator::Allocate ------------------------------------------------
01099
01100 void * SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow )
01101 {
01102     if ( numBytes > GetMaxObjectSize() )
01103         return DefaultAllocator( numBytes, doThrow );
01104
01105     assert( NULL != pool_ );
01106     if ( 0 == numBytes ) numBytes = 1;
01107     const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1;
01108     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
01109     (void) allocCount;
01110     assert( index < allocCount );
01111
01112     FixedAllocator & allocator = pool_[ index ];
01113     assert( allocator.BlockSize() >= numBytes );
01114     assert( allocator.BlockSize() < numBytes + GetAlignment() );
01115     void * place = allocator.Allocate();
01116
01117     if ( ( NULL == place ) && TrimExcessMemory() )
01118         place = allocator.Allocate();
01119
01120     if ( ( NULL == place ) && doThrow )
01121     {
01122 #ifdef _MSC_VER
01123         throw std::bad_alloc( "could not allocate small object" );
01124 #else
01125         // GCC did not like a literal string passed to std::bad_alloc.
01126         // so just throw the default-constructed exception.
01127         throw std::bad_alloc();
01128 #endif
01129     }
01130     return place;
01131 }
01132
01133 // SmallObjAllocator::Deallocate ----------------------------------------------
01134
01135 void SmallObjAllocator::Deallocate( void * p, std::size_t numBytes )
01136 {
01137     if ( NULL == p ) return;
01138     if ( numBytes > GetMaxObjectSize() )
01139     {
01140         DefaultDeallocator( p );
01141         return;
01142     }
01143     assert( NULL != pool_ );
01144     if ( 0 == numBytes ) numBytes = 1;
01145     const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1;
01146     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
01147     (void) allocCount;
01148     assert( index < allocCount );
01149     FixedAllocator & allocator = pool_[ index ];
01150     assert( allocator.BlockSize() >= numBytes );
01151     assert( allocator.BlockSize() < numBytes + GetAlignment() );
01152     const bool found = allocator.Deallocate( p, NULL );
01153     (void) found;
01154     assert( found );
01155 }
01156
01157 // SmallObjAllocator::Deallocate ----------------------------------------------
01158
01159 void SmallObjAllocator::Deallocate( void * p )
01160 {
01161     if ( NULL == p ) return;
01162     assert( NULL != pool_ );
01163     FixedAllocator * pAllocator = NULL;
01164     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
01165     Chunk * chunk = NULL;
01166
01167     for ( std::size_t ii = 0; ii < allocCount; ++ii )
01168     {
01169         chunk = pool_[ ii ].HasBlock( p );
01170         if ( NULL != chunk )
01171         {
01172             pAllocator = &pool_[ ii ];
01173             break;
01174         }
01175     }
01176     if ( NULL == pAllocator )
01177     {
01178         DefaultDeallocator( p );
01179         return;
01180     }
01181
01182     assert( NULL != chunk );
01183     const bool found = pAllocator->Deallocate( p, chunk );
01184     (void) found;
01185     assert( found );
01186 }
01187
01188 // SmallObjAllocator::IsCorrupt -----------------------------------------------
01189
01190 bool SmallObjAllocator::IsCorrupt( void ) const
01191 {
01192     if ( NULL == pool_ )
01193     {
01194         assert( false );
01195         return true;
01196     }
01197     if ( 0 == GetAlignment() )
01198     {
01199         assert( false );
01200         return true;
01201     }
01202     if ( 0 == GetMaxObjectSize() )
01203     {
01204         assert( false );
01205         return true;
01206     }
01207     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
01208     for ( std::size_t ii = 0; ii < allocCount; ++ii )
01209     {
01210         if ( pool_[ ii ].IsCorrupt() )
01211             return true;
01212     }
01213     return false;
01214 }
01215
01216 } // end namespace Loki
01217
Generated on Sat Jul 7 15:11:03 2007 for Loki by doxygen 1.5.1-p1


Loki: SmallObj.h Source File

SmallObj.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_SMALLOBJ_INC_
00016 #define LOKI_SMALLOBJ_INC_
00017
00018 // $Id: SmallObj.h 806 2007-02-03 00:01:52Z rich_sposato $
00019
00020
00021 #include "LokiExport.h"
00022 #include "Threads.h"
00023 #include "Singleton.h"
00024 #include <cstddef>
00025 #include <new> // needed for std::nothrow_t parameter.
00026
00027 #ifndef LOKI_DEFAULT_CHUNK_SIZE
00028 #define LOKI_DEFAULT_CHUNK_SIZE 4096
00029 #endif
00030
00031 #ifndef LOKI_MAX_SMALL_OBJECT_SIZE
00032 #define LOKI_MAX_SMALL_OBJECT_SIZE 256
00033 #endif
00034
00035 #ifndef LOKI_DEFAULT_OBJECT_ALIGNMENT
00036 #define LOKI_DEFAULT_OBJECT_ALIGNMENT 4
00037 #endif
00038
00039 #ifndef LOKI_DEFAULT_SMALLOBJ_LIFETIME
00040 #define LOKI_DEFAULT_SMALLOBJ_LIFETIME ::Loki::LongevityLifetime::DieAsSmallObjectParent
00041 #endif
00042
00043 #if defined(LOKI_SMALL_OBJECT_USE_NEW_ARRAY) && defined(_MSC_VER)
00044 #pragma message("Don't define LOKI_SMALL_OBJECT_USE_NEW_ARRAY when using a Microsoft compiler to prevent memory leaks.")
00045 #pragma message("now calling '#undef LOKI_SMALL_OBJECT_USE_NEW_ARRAY'")
00046 #undef LOKI_SMALL_OBJECT_USE_NEW_ARRAY
00047 #endif
00048
00053
00054 namespace Loki
00055 {
00056     namespace LongevityLifetime
00057     {
00064         template <class T>
00065         struct DieAsSmallObjectParent  : DieLast<T> {};
00066
00073         template <class T>
00074         struct DieAsSmallObjectChild  : DieDirectlyBeforeLast<T> {};
00075
00076     }
00077
00078     class FixedAllocator;
00079
00086     class LOKI_EXPORT SmallObjAllocator
00087     {
00088     protected:
00095         SmallObjAllocator( std::size_t pageSize, std::size_t maxObjectSize,
00096             std::size_t objectAlignSize );
00097
00103         ~SmallObjAllocator( void );
00104
00105     public:
00135         void * Allocate( std::size_t size, bool doThrow );
00136
00141         void Deallocate( void * p, std::size_t size );
00142
00150         void Deallocate( void * p );
00151
00153         inline std::size_t GetMaxObjectSize() const
00154         { return maxSmallObjectSize_; }
00155
00157         inline std::size_t GetAlignment() const { return objectAlignSize_; }
00158
00166         bool TrimExcessMemory( void );
00167
00176         bool IsCorrupt( void ) const;
00177
00178     private:
00180         SmallObjAllocator( void );
00182         SmallObjAllocator( const SmallObjAllocator & );
00184         SmallObjAllocator & operator = ( const SmallObjAllocator & );
00185
00187         Loki::FixedAllocator * pool_;
00188
00190         const std::size_t maxSmallObjectSize_;
00191
00193         const std::size_t objectAlignSize_;
00194     };
00195
00196
00213     template
00214     <
00215         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
00216         std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE,
00217         std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
00218         std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
00219         template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
00220         class MutexPolicy = LOKI_DEFAULT_MUTEX
00221     >
00222     class AllocatorSingleton : public SmallObjAllocator
00223     {
00224     public:
00225
00227         typedef AllocatorSingleton< ThreadingModel, chunkSize,
00228             maxSmallObjectSize, objectAlignSize, LifetimePolicy > MyAllocator;
00229
00231         typedef ThreadingModel< MyAllocator, MutexPolicy > MyThreadingModel;
00232
00234         typedef Loki::SingletonHolder< MyAllocator, Loki::CreateStatic,
00235             LifetimePolicy, ThreadingModel > MyAllocatorSingleton;
00236
00238         inline static AllocatorSingleton & Instance( void )
00239         {
00240             return MyAllocatorSingleton::Instance();
00241         }
00242
00244         inline AllocatorSingleton() :
00245             SmallObjAllocator( chunkSize, maxSmallObjectSize, objectAlignSize )
00246             {}
00247
00249         inline ~AllocatorSingleton( void ) {}
00250
00259         static void ClearExtraMemory( void );
00260
00269         static bool IsCorrupted( void );
00270
00271     private:
00273         AllocatorSingleton( const AllocatorSingleton & );
00275         AllocatorSingleton & operator = ( const AllocatorSingleton & );
00276     };
00277
00278     template
00279     <
00280         template <class, class> class T,
00281         std::size_t C,
00282         std::size_t M,
00283         std::size_t O,
00284         template <class> class L,
00285         class X
00286     >
00287     void AllocatorSingleton< T, C, M, O, L, X >::ClearExtraMemory( void )
00288     {
00289         typename MyThreadingModel::Lock lock;
00290         (void)lock; // get rid of warning
00291         Instance().TrimExcessMemory();
00292     }
00293
00294     template
00295     <
00296         template <class, class> class T,
00297         std::size_t C,
00298         std::size_t M,
00299         std::size_t O,
00300         template <class> class L,
00301         class X
00302     >
00303     bool AllocatorSingleton< T, C, M, O, L, X >::IsCorrupted( void )
00304     {
00305         typename MyThreadingModel::Lock lock;
00306         (void)lock; // get rid of warning
00307         return Instance().IsCorrupt();
00308     }
00309
00322     template
00323     <
00324         template <class, class> class T,
00325         std::size_t C,
00326         std::size_t M,
00327         std::size_t O,
00328         template <class> class L,
00329         class X
00330     >
00331     inline unsigned int GetLongevity(
00332         AllocatorSingleton< T, C, M, O, L, X > * )
00333     {
00334         // Returns highest possible value.
00335         return 0xFFFFFFFF;
00336     }
00337
00338
00427     template
00428     <
00429         template <class, class> class ThreadingModel,
00430         std::size_t chunkSize,
00431         std::size_t maxSmallObjectSize,
00432         std::size_t objectAlignSize,
00433         template <class> class LifetimePolicy,
00434         class MutexPolicy
00435     >
00436     class SmallObjectBase
00437     {
00438
00439 #if (LOKI_MAX_SMALL_OBJECT_SIZE != 0) && (LOKI_DEFAULT_CHUNK_SIZE != 0) && (LOKI_DEFAULT_OBJECT_ALIGNMENT != 0)
00440
00441     public:
00444         typedef AllocatorSingleton< ThreadingModel, chunkSize,
00445             maxSmallObjectSize, objectAlignSize, LifetimePolicy > ObjAllocatorSingleton;
00446
00447     private:
00448
00450         typedef ThreadingModel< ObjAllocatorSingleton, MutexPolicy > MyThreadingModel;
00451
00453         typedef typename ObjAllocatorSingleton::MyAllocatorSingleton MyAllocatorSingleton;
00454
00455     public:
00456
00458 #ifdef _MSC_VER
00460         static void * operator new ( std::size_t size )
00461 #else
00462         static void * operator new ( std::size_t size ) throw ( std::bad_alloc )
00463 #endif
00464         {
00465             typename MyThreadingModel::Lock lock;
00466             (void)lock; // get rid of warning
00467             return MyAllocatorSingleton::Instance().Allocate( size, true );
00468         }
00469
00471         static void * operator new ( std::size_t size, const std::nothrow_t & ) throw ()
00472         {
00473             typename MyThreadingModel::Lock lock;
00474             (void)lock; // get rid of warning
00475             return MyAllocatorSingleton::Instance().Allocate( size, false );
00476         }
00477
00479         inline static void * operator new ( std::size_t size, void * place )
00480         {
00481             return ::operator new( size, place );
00482         }
00483
00485         static void operator delete ( void * p, std::size_t size ) throw ()
00486         {
00487             typename MyThreadingModel::Lock lock;
00488             (void)lock; // get rid of warning
00489             MyAllocatorSingleton::Instance().Deallocate( p, size );
00490         }
00491
00495         static void operator delete ( void * p, const std::nothrow_t & ) throw()
00496         {
00497             typename MyThreadingModel::Lock lock;
00498             (void)lock; // get rid of warning
00499             MyAllocatorSingleton::Instance().Deallocate( p );
00500         }
00501
00503         inline static void operator delete ( void * p, void * place )
00504         {
00505             ::operator delete ( p, place );
00506         }
00507
00508 #ifdef LOKI_SMALL_OBJECT_USE_NEW_ARRAY
00509
00511 #ifdef _MSC_VER
00513         static void * operator new [] ( std::size_t size )
00514 #else
00515         static void * operator new [] ( std::size_t size )
00516             throw ( std::bad_alloc )
00517 #endif
00518         {
00519             typename MyThreadingModel::Lock lock;
00520             (void)lock; // get rid of warning
00521             return MyAllocatorSingleton::Instance().Allocate( size, true );
00522         }
00523
00525         static void * operator new [] ( std::size_t size,
00526             const std::nothrow_t & ) throw ()
00527         {
00528             typename MyThreadingModel::Lock lock;
00529             (void)lock; // get rid of warning
00530             return MyAllocatorSingleton::Instance().Allocate( size, false );
00531         }
00532
00534         inline static void * operator new [] ( std::size_t size, void * place )
00535         {
00536             return ::operator new( size, place );
00537         }
00538
00540         static void operator delete [] ( void * p, std::size_t size ) throw ()
00541         {
00542             typename MyThreadingModel::Lock lock;
00543             (void)lock; // get rid of warning
00544             MyAllocatorSingleton::Instance().Deallocate( p, size );
00545         }
00546
00550         static void operator delete [] ( void * p,
00551             const std::nothrow_t & ) throw()
00552         {
00553             typename MyThreadingModel::Lock lock;
00554             (void)lock; // get rid of warning
00555             MyAllocatorSingleton::Instance().Deallocate( p );
00556         }
00557
00559         inline static void operator delete [] ( void * p, void * place )
00560         {
00561             ::operator delete ( p, place );
00562         }
00563 #endif  // #if use new array functions.
00564
00565 #endif  // #if default template parameters are not zero
00566
00567     protected:
00568         inline SmallObjectBase( void ) {}
00569         inline SmallObjectBase( const SmallObjectBase & ) {}
00570         inline SmallObjectBase & operator = ( const SmallObjectBase & )
00571         { return *this; }
00572         inline ~SmallObjectBase() {}
00573     }; // end class SmallObjectBase
00574
00575
00585     template
00586     <
00587         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
00588         std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE,
00589         std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
00590         std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
00591         template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
00592         class MutexPolicy = LOKI_DEFAULT_MUTEX
00593     >
00594     class SmallObject : public SmallObjectBase< ThreadingModel, chunkSize,
00595             maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
00596     {
00597
00598     public:
00599         virtual ~SmallObject() {}
00600     protected:
00601         inline SmallObject( void ) {}
00602
00603     private:
00605         SmallObject( const SmallObject & );
00607         SmallObject & operator = ( const SmallObject & );
00608     }; // end class SmallObject
00609
00610
00621     template
00622     <
00623         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
00624         std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE,
00625         std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
00626         std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
00627         template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
00628         class MutexPolicy = LOKI_DEFAULT_MUTEX
00629     >
00630     class SmallValueObject : public SmallObjectBase< ThreadingModel, chunkSize,
00631             maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
00632     {
00633     protected:
00634         inline SmallValueObject( void ) {}
00635         inline SmallValueObject( const SmallValueObject & ) {}
00636         inline SmallValueObject & operator = ( const SmallValueObject & )
00637         { return *this; }
00638         inline ~SmallValueObject() {}
00639     }; // end class SmallValueObject
00640
00641 } // namespace Loki
00642
00643 #endif // end file guardian
00644
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: SmartPtr.cpp Source File

SmartPtr.cpp

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // Copyright (c) 2006 Richard Sposato
00005 // This code accompanies the book:
00006 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00007 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00008 // Permission to use, copy, modify, distribute and sell this software for any
00009 //     purpose is hereby granted without fee, provided that the above  copyright
00010 //     notice appear in all copies and that both that copyright notice and this
00011 //     permission notice appear in supporting documentation.
00012 // The author or Addison-Wesley Longman make no representations about the
00013 //     suitability of this software for any purpose. It is provided "as is"
00014 //     without express or implied warranty.
00016
00017 // $Id: SmartPtr.cpp 756 2006-10-17 20:05:42Z syntheticpp $
00018
00019
00020 #include <loki/SmartPtr.h>
00021
00022 #include <cassert>
00023
00024 //#define DO_EXTRA_LOKI_TESTS
00025 #ifdef DO_EXTRA_LOKI_TESTS
00026     #include <iostream>
00027 #endif
00028
00029
00030 // ----------------------------------------------------------------------------
00031
00032 namespace Loki
00033 {
00034
00035 namespace Private
00036 {
00037
00038 // ----------------------------------------------------------------------------
00039
00040 RefLinkedBase::RefLinkedBase(const RefLinkedBase& rhs)
00041 {
00042     prev_ = &rhs;
00043     next_ = rhs.next_;
00044     prev_->next_ = this;
00045     next_->prev_ = this;
00046
00047 #ifdef DO_EXTRA_LOKI_TESTS
00048     assert( prev_->HasPrevNode( this ) );
00049     assert( next_->HasNextNode( this ) );
00050     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00051 #endif
00052 }
00053
00054 // ----------------------------------------------------------------------------
00055
00056 bool RefLinkedBase::Release()
00057 {
00058
00059 #ifdef DO_EXTRA_LOKI_TESTS
00060     assert( prev_->HasPrevNode( this ) );
00061     assert( next_->HasNextNode( this ) );
00062     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00063 #endif
00064
00065     if ( NULL == next_ )
00066     {
00067         assert( NULL == prev_ );
00068         // Return false so it does not try to destroy shared object
00069         // more than once.
00070         return false;
00071     }
00072     else if (next_ == this)
00073     {
00074         assert(prev_ == this);
00075         // Set these to NULL to prevent re-entrancy.
00076         prev_ = NULL;
00077         next_ = NULL;
00078         return true;
00079     }
00080
00081 #ifdef DO_EXTRA_LOKI_TESTS
00082     assert( this != prev_ );
00083     assert( NULL != prev_ );
00084     assert( prev_->HasPrevNode( this ) );
00085     assert( next_->HasNextNode( this ) );
00086 #endif
00087
00088     prev_->next_ = next_;
00089     next_->prev_ = prev_;
00090
00091 #ifdef DO_EXTRA_LOKI_TESTS
00092     next_ = this;
00093     prev_ = this;
00094     assert( 1 == CountNextCycle( this ) );
00095     assert( 1 == CountPrevCycle( this ) );
00096 #endif
00097
00098     return false;
00099 }
00100
00101 // ----------------------------------------------------------------------------
00102
00103 void RefLinkedBase::Swap(RefLinkedBase& rhs)
00104 {
00105
00106 #ifdef DO_EXTRA_LOKI_TESTS
00107     assert( prev_->HasPrevNode( this ) );
00108     assert( next_->HasNextNode( this ) );
00109     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00110 #endif
00111
00112     if (next_ == this)
00113     {
00114         assert(prev_ == this);
00115         if (rhs.next_ == &rhs)
00116         {
00117             assert(rhs.prev_ == &rhs);
00118             // both lists are empty, nothing 2 do
00119             return;
00120         }
00121         prev_ = rhs.prev_;
00122         next_ = rhs.next_;
00123         prev_->next_ = next_->prev_ = this;
00124         rhs.next_ = rhs.prev_ = &rhs;
00125         return;
00126     }
00127     if (rhs.next_ == &rhs)
00128     {
00129         rhs.Swap(*this);
00130         return;
00131     }
00132     if (next_ == &rhs ) // rhs is next neighbour
00133     {
00134         if ( prev_ == &rhs )
00135             return;  // cycle of 2 pointers - no need to swap.
00136         std::swap(prev_, next_);
00137         std::swap(rhs.prev_, rhs.next_);
00138         std::swap(rhs.prev_, next_);
00139         std::swap(rhs.prev_->next_,next_->prev_);
00140     }
00141     else if ( prev_ == &rhs ) // rhs is prev neighbor
00142     {
00143         if ( next_ == &rhs )
00144             return;  // cycle of 2 pointers - no need to swap.
00145         std::swap( prev_, next_ );
00146         std::swap( rhs.next_, rhs.prev_ );
00147         std::swap( rhs.next_, prev_ );
00148         std::swap( rhs.next_->prev_, prev_->next_ );
00149     }
00150     else // not neighhbors
00151     {
00152         std::swap(prev_, rhs.prev_);
00153         std::swap(next_, rhs.next_);
00154         std::swap(prev_->next_, rhs.prev_->next_);
00155         std::swap(next_->prev_, rhs.next_->prev_);
00156     }
00157
00158 #ifdef DO_EXTRA_LOKI_TESTS
00159     assert( next_ == this ? prev_ == this : prev_ != this);
00160     assert( prev_ == this ? next_ == this : next_ != this);
00161     assert( prev_->HasPrevNode( this ) );
00162     assert( next_->HasNextNode( this ) );
00163     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00164     assert( rhs.prev_->HasPrevNode( &rhs ) );
00165     assert( rhs.next_->HasNextNode( &rhs ) );
00166     assert( CountPrevCycle( &rhs ) == CountNextCycle( &rhs ) );
00167 #endif
00168
00169 }
00170
00171 // ----------------------------------------------------------------------------
00172
00173 unsigned int RefLinkedBase::CountPrevCycle( const RefLinkedBase * pThis )
00174 {
00175     if ( NULL == pThis )
00176         return 0;
00177     const RefLinkedBase * p = pThis->prev_;
00178     if ( NULL == p )
00179         return 0;
00180     if ( pThis == p )
00181         return 1;
00182
00183     unsigned int count = 1;
00184     do
00185     {
00186         p = p->prev_;
00187         ++count;
00188     } while ( p != pThis );
00189
00190     return count;
00191 }
00192
00193 // ----------------------------------------------------------------------------
00194
00195 unsigned int RefLinkedBase::CountNextCycle( const RefLinkedBase * pThis )
00196 {
00197     if ( NULL == pThis )
00198         return 0;
00199     const RefLinkedBase * p = pThis->next_;
00200     if ( NULL == p )
00201         return 0;
00202     if ( pThis == p )
00203         return 1;
00204
00205     unsigned int count = 1;
00206     while ( p != pThis )
00207     {
00208         p = p->next_;
00209         ++count;
00210     }
00211
00212     return count;
00213 }
00214
00215 // ----------------------------------------------------------------------------
00216
00217 bool RefLinkedBase::HasPrevNode( const RefLinkedBase * p ) const
00218 {
00219     if ( this == p )
00220         return true;
00221     const RefLinkedBase * prev = prev_;
00222     if ( NULL == prev )
00223         return false;
00224     while ( prev != this )
00225     {
00226         if ( p == prev )
00227             return true;
00228         prev = prev->prev_;
00229     }
00230     return false;
00231 }
00232
00233 // ----------------------------------------------------------------------------
00234
00235 bool RefLinkedBase::HasNextNode( const RefLinkedBase * p ) const
00236 {
00237     if ( this == p )
00238         return true;
00239     const RefLinkedBase * next = next_;
00240     if ( NULL == next )
00241         return false;
00242     while ( next != this )
00243     {
00244         if ( p == next )
00245             return true;
00246         next = next->next_;
00247     }
00248     return false;
00249 }
00250
00251 // ----------------------------------------------------------------------------
00252
00253 bool RefLinkedBase::Merge( RefLinkedBase & rhs )
00254 {
00255
00256     if ( NULL == next_ )
00257     {
00258         assert( NULL == prev_ );
00259         return false;
00260     }
00261     RefLinkedBase * prhs = &rhs;
00262     if ( prhs == this )
00263         return true;
00264     if ( NULL == prhs->next_ )
00265     {
00266         assert( NULL == prhs->prev_ );
00267         return true;
00268     }
00269
00270     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00271     assert( CountPrevCycle( prhs ) == CountNextCycle( prhs ) );
00272     // If rhs node is already in this cycle, then no need to merge.
00273     if ( HasPrevNode( &rhs ) )
00274     {
00275         assert( HasNextNode( &rhs ) );
00276         return true;
00277     }
00278
00279     if ( prhs == prhs->next_ )
00280     {
00282         assert( prhs->prev_ == prhs );
00283         prhs->prev_ = prev_;
00284         prhs->next_ = this;
00285         prev_->next_ = prhs;
00286         prev_ = prhs;
00287     }
00288     else if ( this == next_ )
00289     {
00291         assert( prev_ == this );
00292         prev_ = prhs->prev_;
00293         next_ = prhs;
00294         prhs->prev_->next_ = this;
00295         prhs->prev_ = this;
00296     }
00297     else
00298     {
00299         next_->prev_ = prhs->prev_;
00300         prhs->prev_->next_ = prev_;
00301         next_ = prhs;
00302         prhs->prev_ = this;
00303     }
00304
00305     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00306     return true;
00307 }
00308
00309 // ----------------------------------------------------------------------------
00310
00311 } // end namespace Private
00312
00313 } // end namespace Loki
00314
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: SmartPtr.h Source File

SmartPtr.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_SMARTPTR_INC_
00016 #define LOKI_SMARTPTR_INC_
00017
00018 // $Id: SmartPtr.h 791 2006-12-15 01:36:29Z rich_sposato $
00019
00020
00031
00032 #include "LokiExport.h"
00033 #include "SmallObj.h"
00034 #include "TypeManip.h"
00035 #include "static_check.h"
00036 #include "RefToValue.h"
00037 #include "ConstPolicy.h"
00038
00039 #include <functional>
00040 #include <stdexcept>
00041 #include <cassert>
00042 #include <string>
00043
00044 #if !defined(_MSC_VER)
00045     #include <stdint.h>
00046 #endif
00047
00048 #if defined(_MSC_VER) || defined(__GNUC__)
00049 // GCC>=4.1 must use -ffriend-injection due to a bug in GCC
00050 #define LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
00051 #endif
00052
00053
00054 namespace Loki
00055 {
00056
00064
00065
00066     template <class T>
00067     class HeapStorage
00068     {
00069     public:
00070         typedef T* StoredType;
00071         typedef T* InitPointerType;
00072         typedef T* PointerType;
00073         typedef T& ReferenceType;
00074
00075         HeapStorage() : pointee_(Default())
00076         {}
00077
00078         // The storage policy doesn't initialize the stored pointer
00079         //     which will be initialized by the OwnershipPolicy's Clone fn
00080         HeapStorage(const HeapStorage&) : pointee_(0)
00081         {}
00082
00083         template <class U>
00084         HeapStorage(const HeapStorage<U>&) : pointee_(0)
00085         {}
00086
00087         HeapStorage(const StoredType& p) : pointee_(p) {}
00088
00089         PointerType operator->() const { return pointee_; }
00090
00091         ReferenceType operator*() const { return *pointee_; }
00092
00093         void Swap(HeapStorage& rhs)
00094         { std::swap(pointee_, rhs.pointee_); }
00095
00096         // Accessors
00097         template <class F>
00098         friend typename HeapStorage<F>::PointerType GetImpl(const HeapStorage<F>& sp);
00099
00100         template <class F>
00101         friend const typename HeapStorage<F>::StoredType& GetImplRef(const HeapStorage<F>& sp);
00102
00103         template <class F>
00104         friend typename HeapStorage<F>::StoredType& GetImplRef(HeapStorage<F>& sp);
00105
00106     protected:
00107         // Destroys the data stored
00108         // (Destruction might be taken over by the OwnershipPolicy)
00109         void Destroy()
00110         {
00111             if ( 0 != pointee_ )
00112             {
00113                 pointee_->~T();
00114                 ::free( pointee_ );
00115             }
00116         }
00117
00118         // Default value to initialize the pointer
00119         static StoredType Default()
00120         { return 0; }
00121
00122     private:
00123         // Data
00124         StoredType pointee_;
00125     };
00126
00127     template <class T>
00128     inline typename HeapStorage<T>::PointerType GetImpl(const HeapStorage<T>& sp)
00129     { return sp.pointee_; }
00130
00131     template <class T>
00132     inline const typename HeapStorage<T>::StoredType& GetImplRef(const HeapStorage<T>& sp)
00133     { return sp.pointee_; }
00134
00135     template <class T>
00136     inline typename HeapStorage<T>::StoredType& GetImplRef(HeapStorage<T>& sp)
00137     { return sp.pointee_; }
00138
00139
00146
00147
00148     template <class T>
00149     class DefaultSPStorage
00150     {
00151     public:
00152         typedef T* StoredType;    // the type of the pointee_ object
00153         typedef T* InitPointerType;
00154         typedef T* PointerType;   // type returned by operator->
00155         typedef T& ReferenceType; // type returned by operator*
00156
00157         DefaultSPStorage() : pointee_(Default())
00158         {}
00159
00160         // The storage policy doesn't initialize the stored pointer
00161         //     which will be initialized by the OwnershipPolicy's Clone fn
00162         DefaultSPStorage(const DefaultSPStorage&) : pointee_(0)
00163         {}
00164
00165         template <class U>
00166         DefaultSPStorage(const DefaultSPStorage<U>&) : pointee_(0)
00167         {}
00168
00169         DefaultSPStorage(const StoredType& p) : pointee_(p) {}
00170
00171         PointerType operator->() const { return pointee_; }
00172
00173         ReferenceType operator*() const { return *pointee_; }
00174
00175         void Swap(DefaultSPStorage& rhs)
00176         { std::swap(pointee_, rhs.pointee_); }
00177
00178         // Accessors
00179         template <class F>
00180         friend typename DefaultSPStorage<F>::PointerType GetImpl(const DefaultSPStorage<F>& sp);
00181
00182         template <class F>
00183         friend const typename DefaultSPStorage<F>::StoredType& GetImplRef(const DefaultSPStorage<F>& sp);
00184
00185         template <class F>
00186         friend typename DefaultSPStorage<F>::StoredType& GetImplRef(DefaultSPStorage<F>& sp);
00187
00188     protected:
00189         // Destroys the data stored
00190         // (Destruction might be taken over by the OwnershipPolicy)
00191         void Destroy()
00192         {
00193             delete pointee_;
00194         }
00195
00196         // Default value to initialize the pointer
00197         static StoredType Default()
00198         { return 0; }
00199
00200     private:
00201         // Data
00202         StoredType pointee_;
00203     };
00204
00205     template <class T>
00206     inline typename DefaultSPStorage<T>::PointerType GetImpl(const DefaultSPStorage<T>& sp)
00207     { return sp.pointee_; }
00208
00209     template <class T>
00210     inline const typename DefaultSPStorage<T>::StoredType& GetImplRef(const DefaultSPStorage<T>& sp)
00211     { return sp.pointee_; }
00212
00213     template <class T>
00214     inline typename DefaultSPStorage<T>::StoredType& GetImplRef(DefaultSPStorage<T>& sp)
00215     { return sp.pointee_; }
00216
00217
00240
00241     template <class T>
00242     class Locker
00243     {
00244     public:
00245         Locker( const T * p ) : pointee_( const_cast< T * >( p ) )
00246         {
00247             if ( pointee_ != 0 )
00248                 pointee_->Lock();
00249         }
00250
00251         ~Locker( void )
00252         {
00253             if ( pointee_ != 0 )
00254                 pointee_->Unlock();
00255         }
00256
00257         operator T * ()
00258         {
00259             return pointee_;
00260         }
00261
00262         T * operator->()
00263         {
00264             return pointee_;
00265         }
00266
00267     private:
00268         Locker( void );
00269         Locker & operator = ( const Locker & );
00270         T * pointee_;
00271     };
00272
00273     template <class T>
00274     class LockedStorage
00275     {
00276     public:
00277
00278         typedef T* StoredType;
00279         typedef T* InitPointerType;
00280         typedef Locker< T > PointerType;
00281         typedef T& ReferenceType;
00282
00283         LockedStorage() : pointee_( Default() ) {}
00284
00285         ~LockedStorage( void ) {}
00286
00287         LockedStorage( const LockedStorage&) : pointee_( 0 ) {}
00288
00289         LockedStorage( const StoredType & p ) : pointee_( p ) {}
00290
00291         PointerType operator->()
00292         {
00293             return Locker< T >( pointee_ );
00294         }
00295
00296         void Swap(LockedStorage& rhs)
00297         {
00298             std::swap( pointee_, rhs.pointee_ );
00299         }
00300
00301         // Accessors
00302         template <class F>
00303         friend typename LockedStorage<F>::InitPointerType GetImpl(const LockedStorage<F>& sp);
00304
00305         template <class F>
00306         friend const typename LockedStorage<F>::StoredType& GetImplRef(const LockedStorage<F>& sp);
00307
00308         template <class F>
00309         friend typename LockedStorage<F>::StoredType& GetImplRef(LockedStorage<F>& sp);
00310
00311     protected:
00312         // Destroys the data stored
00313         // (Destruction might be taken over by the OwnershipPolicy)
00314         void Destroy()
00315         {
00316             delete pointee_;
00317         }
00318
00319         // Default value to initialize the pointer
00320         static StoredType Default()
00321         { return 0; }
00322
00323     private:
00325         ReferenceType operator*();
00326
00327         // Data
00328         StoredType pointee_;
00329     };
00330
00331     template <class T>
00332     inline typename LockedStorage<T>::InitPointerType GetImpl(const LockedStorage<T>& sp)
00333     { return sp.pointee_; }
00334
00335     template <class T>
00336     inline const typename LockedStorage<T>::StoredType& GetImplRef(const LockedStorage<T>& sp)
00337     { return sp.pointee_; }
00338
00339     template <class T>
00340     inline typename LockedStorage<T>::StoredType& GetImplRef(LockedStorage<T>& sp)
00341     { return sp.pointee_; }
00342
00343
00350
00351
00352     template <class T>
00353     class ArrayStorage
00354     {
00355     public:
00356         typedef T* StoredType;    // the type of the pointee_ object
00357         typedef T* InitPointerType;
00358         typedef T* PointerType;   // type returned by operator->
00359         typedef T& ReferenceType; // type returned by operator*
00360
00361         ArrayStorage() : pointee_(Default())
00362         {}
00363
00364         // The storage policy doesn't initialize the stored pointer
00365         //     which will be initialized by the OwnershipPolicy's Clone fn
00366         ArrayStorage(const ArrayStorage&) : pointee_(0)
00367         {}
00368
00369         template <class U>
00370         ArrayStorage(const ArrayStorage<U>&) : pointee_(0)
00371         {}
00372
00373         ArrayStorage(const StoredType& p) : pointee_(p) {}
00374
00375         PointerType operator->() const { return pointee_; }
00376
00377         ReferenceType operator*() const { return *pointee_; }
00378
00379         void Swap(ArrayStorage& rhs)
00380         { std::swap(pointee_, rhs.pointee_); }
00381
00382         // Accessors
00383         template <class F>
00384         friend typename ArrayStorage<F>::PointerType GetImpl(const ArrayStorage<F>& sp);
00385
00386         template <class F>
00387         friend const typename ArrayStorage<F>::StoredType& GetImplRef(const ArrayStorage<F>& sp);
00388
00389         template <class F>
00390         friend typename ArrayStorage<F>::StoredType& GetImplRef(ArrayStorage<F>& sp);
00391
00392     protected:
00393         // Destroys the data stored
00394         // (Destruction might be taken over by the OwnershipPolicy)
00395         void Destroy()
00396         { delete [] pointee_; }
00397
00398         // Default value to initialize the pointer
00399         static StoredType Default()
00400         { return 0; }
00401
00402     private:
00403         // Data
00404         StoredType pointee_;
00405     };
00406
00407     template <class T>
00408     inline typename ArrayStorage<T>::PointerType GetImpl(const ArrayStorage<T>& sp)
00409     { return sp.pointee_; }
00410
00411     template <class T>
00412     inline const typename ArrayStorage<T>::StoredType& GetImplRef(const ArrayStorage<T>& sp)
00413     { return sp.pointee_; }
00414
00415     template <class T>
00416     inline typename ArrayStorage<T>::StoredType& GetImplRef(ArrayStorage<T>& sp)
00417     { return sp.pointee_; }
00418
00419
00427
00428     template <class P>
00429     class RefCounted
00430     {
00431     public:
00432         RefCounted()
00433             : pCount_(static_cast<uintptr_t*>(
00434                 SmallObject<>::operator new(sizeof(uintptr_t))))
00435         {
00436             assert(pCount_!=0);
00437             *pCount_ = 1;
00438         }
00439
00440         RefCounted(const RefCounted& rhs)
00441         : pCount_(rhs.pCount_)
00442         {}
00443
00444         // MWCW lacks template friends, hence the following kludge
00445         template <typename P1>
00446         RefCounted(const RefCounted<P1>& rhs)
00447         : pCount_(reinterpret_cast<const RefCounted&>(rhs).pCount_)
00448         {}
00449
00450         P Clone(const P& val)
00451         {
00452             ++*pCount_;
00453             return val;
00454         }
00455
00456         bool Release(const P&)
00457         {
00458             if (!--*pCount_)
00459             {
00460                 SmallObject<>::operator delete(pCount_, sizeof(uintptr_t));
00461                 pCount_ = NULL;
00462                 return true;
00463             }
00464             return false;
00465         }
00466
00467         void Swap(RefCounted& rhs)
00468         { std::swap(pCount_, rhs.pCount_); }
00469
00470         enum { destructiveCopy = false };
00471
00472     private:
00473         // Data
00474         uintptr_t* pCount_;
00475     };
00476
00489
00490     template <template <class, class> class ThreadingModel,
00491               class MX = LOKI_DEFAULT_MUTEX >
00492     struct RefCountedMTAdj
00493     {
00494         template <class P>
00495         class RefCountedMT : public ThreadingModel< RefCountedMT<P>, MX >
00496         {
00497             typedef ThreadingModel< RefCountedMT<P>, MX > base_type;
00498             typedef typename base_type::IntType       CountType;
00499             typedef volatile CountType               *CountPtrType;
00500
00501         public:
00502             RefCountedMT()
00503             {
00504                 pCount_ = static_cast<CountPtrType>(
00505                     SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator new(
00506                         sizeof(*pCount_)));
00507                 assert(pCount_);
00508                 //*pCount_ = 1;
00509                 ThreadingModel<RefCountedMT, MX>::AtomicAssign(*pCount_, 1);
00510             }
00511
00512             RefCountedMT(const RefCountedMT& rhs)
00513             : pCount_(rhs.pCount_)
00514             {}
00515
00516             //MWCW lacks template friends, hence the following kludge
00517             template <typename P1>
00518             RefCountedMT(const RefCountedMT<P1>& rhs)
00519             : pCount_(reinterpret_cast<const RefCountedMT<P>&>(rhs).pCount_)
00520             {}
00521
00522             P Clone(const P& val)
00523             {
00524                 ThreadingModel<RefCountedMT, MX>::AtomicIncrement(*pCount_);
00525                 return val;
00526             }
00527
00528             bool Release(const P&)
00529             {
00530                 if (!ThreadingModel<RefCountedMT, MX>::AtomicDecrement(*pCount_))
00531                 {
00532                     SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator delete(
00533                         const_cast<CountType *>(pCount_),
00534                         sizeof(*pCount_));
00535                     return true;
00536                 }
00537                 return false;
00538             }
00539
00540             void Swap(RefCountedMT& rhs)
00541             { std::swap(pCount_, rhs.pCount_); }
00542
00543             enum { destructiveCopy = false };
00544
00545         private:
00546             // Data
00547             CountPtrType pCount_;
00548         };
00549     };
00550
00558
00559     template <class P>
00560     class COMRefCounted
00561     {
00562     public:
00563         COMRefCounted()
00564         {}
00565
00566         template <class U>
00567         COMRefCounted(const COMRefCounted<U>&)
00568         {}
00569
00570         static P Clone(const P& val)
00571         {
00572             if(val!=0)
00573                val->AddRef();
00574             return val;
00575         }
00576
00577         static bool Release(const P& val)
00578         {
00579             if(val!=0)
00580                 val->Release();
00581             return false;
00582         }
00583
00584         enum { destructiveCopy = false };
00585
00586         static void Swap(COMRefCounted&)
00587         {}
00588     };
00589
00598
00599     template <class P>
00600     struct DeepCopy
00601     {
00602         DeepCopy()
00603         {}
00604
00605         template <class P1>
00606         DeepCopy(const DeepCopy<P1>&)
00607         {}
00608
00609         static P Clone(const P& val)
00610         { return val->Clone(); }
00611
00612         static bool Release(const P&)
00613         { return true; }
00614
00615         static void Swap(DeepCopy&)
00616         {}
00617
00618         enum { destructiveCopy = false };
00619     };
00620
00628
00629     namespace Private
00630     {
00631         class LOKI_EXPORT RefLinkedBase
00632         {
00633         public:
00634             RefLinkedBase()
00635             { prev_ = next_ = this; }
00636
00637             RefLinkedBase(const RefLinkedBase& rhs);
00638
00639             bool Release();
00640
00641             void Swap(RefLinkedBase& rhs);
00642
00643             bool Merge( RefLinkedBase & rhs );
00644
00645             enum { destructiveCopy = false };
00646
00647         private:
00648             static unsigned int CountPrevCycle( const RefLinkedBase * pThis );
00649             static unsigned int CountNextCycle( const RefLinkedBase * pThis );
00650             bool HasPrevNode( const RefLinkedBase * p ) const;
00651             bool HasNextNode( const RefLinkedBase * p ) const;
00652
00653             mutable const RefLinkedBase* prev_;
00654             mutable const RefLinkedBase* next_;
00655         };
00656     }
00657
00658     template <class P>
00659     class RefLinked : public Private::RefLinkedBase
00660     {
00661     public:
00662         RefLinked()
00663         {}
00664
00665         template <class P1>
00666         RefLinked(const RefLinked<P1>& rhs)
00667         : Private::RefLinkedBase(rhs)
00668         {}
00669
00670         static P Clone(const P& val)
00671         { return val; }
00672
00673         bool Release(const P&)
00674         { return Private::RefLinkedBase::Release(); }
00675
00676         template < class P1 >
00677         bool Merge( RefLinked< P1 > & rhs )
00678         {
00679             return Private::RefLinkedBase::Merge( rhs );
00680         }
00681     };
00682
00690
00691     template <class P>
00692     class DestructiveCopy
00693     {
00694     public:
00695         DestructiveCopy()
00696         {}
00697
00698         template <class P1>
00699         DestructiveCopy(const DestructiveCopy<P1>&)
00700         {}
00701
00702         template <class P1>
00703         static P Clone(P1& val)
00704         {
00705             P result(val);
00706             val = P1();
00707             return result;
00708         }
00709
00710         static bool Release(const P&)
00711         { return true; }
00712
00713         static void Swap(DestructiveCopy&)
00714         {}
00715
00716         enum { destructiveCopy = true };
00717     };
00718
00726
00727     template <class P>
00728     class NoCopy
00729     {
00730     public:
00731         NoCopy()
00732         {}
00733
00734         template <class P1>
00735         NoCopy(const NoCopy<P1>&)
00736         {}
00737
00738         static P Clone(const P&)
00739         {
00740             // Make it depended on template parameter
00741             static const bool DependedFalse = sizeof(P*) == 0;
00742
00743             LOKI_STATIC_CHECK(DependedFalse, This_Policy_Disallows_Value_Copying);
00744         }
00745
00746         static bool Release(const P&)
00747         { return true; }
00748
00749         static void Swap(NoCopy&)
00750         {}
00751
00752         enum { destructiveCopy = false };
00753     };
00754
00762
00763     struct AllowConversion
00764     {
00765         enum { allow = true };
00766
00767         void Swap(AllowConversion&)
00768         {}
00769     };
00770
00779
00780     struct DisallowConversion
00781     {
00782         DisallowConversion()
00783         {}
00784
00785         DisallowConversion(const AllowConversion&)
00786         {}
00787
00788         enum { allow = false };
00789
00790         void Swap(DisallowConversion&)
00791         {}
00792     };
00793
00801
00802     template <class P>
00803     struct NoCheck
00804     {
00805         NoCheck()
00806         {}
00807
00808         template <class P1>
00809         NoCheck(const NoCheck<P1>&)
00810         {}
00811
00812         static void OnDefault(const P&)
00813         {}
00814
00815         static void OnInit(const P&)
00816         {}
00817
00818         static void OnDereference(const P&)
00819         {}
00820
00821         static void Swap(NoCheck&)
00822         {}
00823     };
00824
00825
00833
00834     template <class P>
00835     struct AssertCheck
00836     {
00837         AssertCheck()
00838         {}
00839
00840         template <class P1>
00841         AssertCheck(const AssertCheck<P1>&)
00842         {}
00843
00844         template <class P1>
00845         AssertCheck(const NoCheck<P1>&)
00846         {}
00847
00848         static void OnDefault(const P&)
00849         {}
00850
00851         static void OnInit(const P&)
00852         {}
00853
00854         static void OnDereference(P val)
00855         { assert(val); (void)val; }
00856
00857         static void Swap(AssertCheck&)
00858         {}
00859     };
00860
00869
00870     template <class P>
00871     struct AssertCheckStrict
00872     {
00873         AssertCheckStrict()
00874         {}
00875
00876         template <class U>
00877         AssertCheckStrict(const AssertCheckStrict<U>&)
00878         {}
00879
00880         template <class U>
00881         AssertCheckStrict(const AssertCheck<U>&)
00882         {}
00883
00884         template <class P1>
00885         AssertCheckStrict(const NoCheck<P1>&)
00886         {}
00887
00888         static void OnDefault(P val)
00889         { assert(val); }
00890
00891         static void OnInit(P val)
00892         { assert(val); }
00893
00894         static void OnDereference(P val)
00895         { assert(val); }
00896
00897         static void Swap(AssertCheckStrict&)
00898         {}
00899     };
00900
00907
00908     struct NullPointerException : public std::runtime_error
00909     {
00910         NullPointerException() : std::runtime_error(std::string(""))
00911         { }
00912         const char* what() const throw()
00913         { return "Null Pointer Exception"; }
00914     };
00915
00923
00924     template <class P>
00925     struct RejectNullStatic
00926     {
00927         RejectNullStatic()
00928         {}
00929
00930         template <class P1>
00931         RejectNullStatic(const RejectNullStatic<P1>&)
00932         {}
00933
00934         template <class P1>
00935         RejectNullStatic(const NoCheck<P1>&)
00936         {}
00937
00938         template <class P1>
00939         RejectNullStatic(const AssertCheck<P1>&)
00940         {}
00941
00942         template <class P1>
00943         RejectNullStatic(const AssertCheckStrict<P1>&)
00944         {}
00945
00946         static void OnDefault(const P&)
00947         {
00948             // Make it depended on template parameter
00949             static const bool DependedFalse = sizeof(P*) == 0;
00950
00951             LOKI_STATIC_CHECK(DependedFalse, ERROR_This_Policy_Does_Not_Allow_Default_Initialization);
00952         }
00953
00954         static void OnInit(const P& val)
00955         { if (!val) throw NullPointerException(); }
00956
00957         static void OnDereference(const P& val)
00958         { if (!val) throw NullPointerException(); }
00959
00960         static void Swap(RejectNullStatic&)
00961         {}
00962     };
00963
00971
00972     template <class P>
00973     struct RejectNull
00974     {
00975         RejectNull()
00976         {}
00977
00978         template <class P1>
00979         RejectNull(const RejectNull<P1>&)
00980         {}
00981
00982         static void OnInit(P)
00983         {}
00984
00985         static void OnDefault(P)
00986         {}
00987
00988         void OnDereference(P val)
00989         { if (!val) throw NullPointerException(); }
00990
00991         void OnDereference(P val) const
00992         { if (!val) throw NullPointerException(); }
00993
00994         void Swap(RejectNull&)
00995         {}
00996     };
00997
01005
01006     template <class P>
01007     struct RejectNullStrict
01008     {
01009         RejectNullStrict()
01010         {}
01011
01012         template <class P1>
01013         RejectNullStrict(const RejectNullStrict<P1>&)
01014         {}
01015
01016         template <class P1>
01017         RejectNullStrict(const RejectNull<P1>&)
01018         {}
01019
01020         static void OnInit(P val)
01021         { if (!val) throw NullPointerException(); }
01022
01023         void OnDereference(P val)
01024         { OnInit(val); }
01025
01026         void OnDereference(P val) const
01027         { OnInit(val); }
01028
01029         void Swap(RejectNullStrict&)
01030         {}
01031     };
01032
01033
01035 // class template SmartPtr (declaration)
01036 // The reason for all the fuss above
01038
01039     template
01040     <
01041         typename T,
01042         template <class> class OwnershipPolicy = RefCounted,
01043         class ConversionPolicy = DisallowConversion,
01044         template <class> class CheckingPolicy = AssertCheck,
01045         template <class> class StoragePolicy = DefaultSPStorage,
01046         template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
01047      >
01048      class SmartPtr;
01049
01051 // class template SmartPtrDef (definition)
01052 // this class added to unify the usage of SmartPtr
01053 // instead of writing SmartPtr<T,OP,CP,KP,SP> write SmartPtrDef<T,OP,CP,KP,SP>::type
01055
01056     template
01057     <
01058         typename T,
01059         template <class> class OwnershipPolicy = RefCounted,
01060         class ConversionPolicy = DisallowConversion,
01061         template <class> class CheckingPolicy = AssertCheck,
01062         template <class> class StoragePolicy = DefaultSPStorage,
01063         template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
01064     >
01065     struct SmartPtrDef
01066     {
01067         typedef SmartPtr
01068         <
01069             T,
01070             OwnershipPolicy,
01071             ConversionPolicy,
01072             CheckingPolicy,
01073             StoragePolicy,
01074             ConstnessPolicy
01075         >
01076         type;
01077     };
01078
01097
01098     template
01099     <
01100         typename T,
01101         template <class> class OwnershipPolicy,
01102         class ConversionPolicy,
01103         template <class> class CheckingPolicy,
01104         template <class> class StoragePolicy,
01105         template <class> class ConstnessPolicy
01106     >
01107     class SmartPtr
01108         : public StoragePolicy<T>
01109         , public OwnershipPolicy<typename StoragePolicy<T>::InitPointerType>
01110         , public CheckingPolicy<typename StoragePolicy<T>::StoredType>
01111         , public ConversionPolicy
01112     {
01113         typedef StoragePolicy<T> SP;
01114         typedef OwnershipPolicy<typename StoragePolicy<T>::InitPointerType> OP;
01115         typedef CheckingPolicy<typename StoragePolicy<T>::StoredType> KP;
01116         typedef ConversionPolicy CP;
01117
01118     public:
01119         typedef typename ConstnessPolicy<T>::Type* ConstPointerType;
01120         typedef typename ConstnessPolicy<T>::Type& ConstReferenceType;
01121
01122         typedef typename SP::PointerType PointerType;
01123         typedef typename SP::StoredType StoredType;
01124         typedef typename SP::ReferenceType ReferenceType;
01125
01126         typedef typename Select<OP::destructiveCopy,SmartPtr, const SmartPtr>::Result
01127                 CopyArg;
01128
01129     private:
01130         struct NeverMatched {};
01131
01132 #ifdef LOKI_SMARTPTR_CONVERSION_CONSTRUCTOR_POLICY
01133         typedef typename Select< CP::allow, const StoredType&, NeverMatched>::Result ImplicitArg;
01134         typedef typename Select<!CP::allow, const StoredType&, NeverMatched>::Result ExplicitArg;
01135 #else
01136         typedef const StoredType& ImplicitArg;
01137         typedef typename Select<false, const StoredType&, NeverMatched>::Result ExplicitArg;
01138 #endif
01139
01140     public:
01141
01142         SmartPtr()
01143         {
01144             KP::OnDefault(GetImpl(*this));
01145         }
01146
01147         explicit
01148         SmartPtr(ExplicitArg p) : SP(p)
01149         {
01150             KP::OnInit(GetImpl(*this));
01151         }
01152
01153         SmartPtr(ImplicitArg p) : SP(p)
01154         {
01155             KP::OnInit(GetImpl(*this));
01156         }
01157
01158         SmartPtr(CopyArg& rhs) : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
01159         {
01160             GetImplRef(*this) = OP::Clone(GetImplRef(rhs));
01161         }
01162
01163         template
01164         <
01165             typename T1,
01166             template <class> class OP1,
01167             class CP1,
01168             template <class> class KP1,
01169             template <class> class SP1,
01170             template <class> class CNP1
01171         >
01172         SmartPtr(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
01173         : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
01174         { GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); }
01175
01176         template
01177         <
01178             typename T1,
01179             template <class> class OP1,
01180             class CP1,
01181             template <class> class KP1,
01182             template <class> class SP1,
01183             template <class> class CNP1
01184         >
01185         SmartPtr(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
01186         : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
01187         {
01188             GetImplRef(*this) = OP::Clone(GetImplRef(rhs));
01189         }
01190
01191         SmartPtr(RefToValue<SmartPtr> rhs)
01192         : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
01193         {}
01194
01195         operator RefToValue<SmartPtr>()
01196         { return RefToValue<SmartPtr>(*this); }
01197
01198         SmartPtr& operator=(CopyArg& rhs)
01199         {
01200             SmartPtr temp(rhs);
01201             temp.Swap(*this);
01202             return *this;
01203         }
01204
01205         template
01206         <
01207             typename T1,
01208             template <class> class OP1,
01209             class CP1,
01210             template <class> class KP1,
01211             template <class> class SP1,
01212             template <class> class CNP1
01213         >
01214         SmartPtr& operator=(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
01215         {
01216             SmartPtr temp(rhs);
01217             temp.Swap(*this);
01218             return *this;
01219         }
01220
01221         template
01222         <
01223             typename T1,
01224             template <class> class OP1,
01225             class CP1,
01226             template <class> class KP1,
01227             template <class> class SP1,
01228             template <class> class CNP1
01229         >
01230         SmartPtr& operator=(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
01231         {
01232             SmartPtr temp(rhs);
01233             temp.Swap(*this);
01234             return *this;
01235         }
01236
01237         void Swap(SmartPtr& rhs)
01238         {
01239             OP::Swap(rhs);
01240             CP::Swap(rhs);
01241             KP::Swap(rhs);
01242             SP::Swap(rhs);
01243         }
01244
01245         ~SmartPtr()
01246         {
01247             if (OP::Release(GetImpl(*static_cast<SP*>(this))))
01248             {
01249                 SP::Destroy();
01250             }
01251         }
01252
01253 #ifdef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
01254
01255         // old non standard in class definition of friends
01256         friend inline void Release(SmartPtr& sp, typename SP::StoredType& p)
01257         {
01258             p = GetImplRef(sp);
01259             GetImplRef(sp) = SP::Default();
01260         }
01261
01262         friend inline void Reset(SmartPtr& sp, typename SP::StoredType p)
01263         { SmartPtr(p).Swap(sp); }
01264
01265 #else
01266
01267         template
01268         <
01269             typename T1,
01270             template <class> class OP1,
01271             class CP1,
01272             template <class> class KP1,
01273             template <class> class SP1,
01274             template <class> class CNP1
01275         >
01276         friend void Release(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1>& sp,
01277                             typename SP1<T1>::StoredType& p);
01278
01279         template
01280         <
01281             typename T1,
01282             template <class> class OP1,
01283             class CP1,
01284             template <class> class KP1,
01285             template <class> class SP1,
01286             template <class> class CNP1
01287         >
01288         friend void Reset(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1>& sp,
01289                           typename SP1<T1>::StoredType p);
01290 #endif
01291
01292
01293         template
01294         <
01295             typename T1,
01296             template <class> class OP1,
01297             class CP1,
01298             template <class> class KP1,
01299             template <class> class SP1,
01300             template <class> class CNP1
01301         >
01302         bool Merge( SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
01303         {
01304             if ( GetImpl( *this ) != GetImpl( rhs ) )
01305             {
01306                 return false;
01307             }
01308             return OP::template Merge( rhs );
01309         }
01310
01311         PointerType operator->()
01312         {
01313             KP::OnDereference(GetImplRef(*this));
01314             return SP::operator->();
01315         }
01316
01317         ConstPointerType operator->() const
01318         {
01319             KP::OnDereference(GetImplRef(*this));
01320             return SP::operator->();
01321         }
01322
01323         ReferenceType operator*()
01324         {
01325             KP::OnDereference(GetImplRef(*this));
01326             return SP::operator*();
01327         }
01328
01329         ConstReferenceType operator*() const
01330         {
01331             KP::OnDereference(GetImplRef(*this));
01332             return SP::operator*();
01333         }
01334
01335         bool operator!() const // Enables "if (!sp) ..."
01336         { return GetImpl(*this) == 0; }
01337
01338         static inline T * GetPointer( const SmartPtr & sp )
01339         { return GetImpl( sp ); }
01340
01341         // Ambiguity buster
01342         template
01343         <
01344             typename T1,
01345             template <class> class OP1,
01346             class CP1,
01347             template <class> class KP1,
01348             template <class> class SP1,
01349             template <class> class CNP1
01350         >
01351         bool operator==(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const
01352         { return GetImpl(*this) == GetImpl(rhs); }
01353
01354         // Ambiguity buster
01355         template
01356         <
01357             typename T1,
01358             template <class> class OP1,
01359             class CP1,
01360             template <class> class KP1,
01361             template <class> class SP1,
01362             template <class> class CNP1
01363         >
01364         bool operator!=(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const
01365         { return !(*this == rhs); }
01366
01367         // Ambiguity buster
01368         template
01369         <
01370             typename T1,
01371             template <class> class OP1,
01372             class CP1,
01373             template <class> class KP1,
01374             template <class> class SP1,
01375             template <class> class CNP1
01376         >
01377         bool operator<(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const
01378         { return GetImpl(*this) < GetImpl(rhs); }
01379
01380         // Ambiguity buster
01381         template
01382         <
01383             typename T1,
01384             template <class> class OP1,
01385             class CP1,
01386             template <class> class KP1,
01387             template <class> class SP1,
01388             template <class> class CNP1
01389         >
01390         inline bool operator > ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
01391         {
01392             return ( GetImpl( rhs ) < GetImpl( *this ) );
01393         }
01394
01395         // Ambiguity buster
01396         template
01397         <
01398             typename T1,
01399             template <class> class OP1,
01400             class CP1,
01401             template <class> class KP1,
01402             template <class> class SP1,
01403             template <class> class CNP1
01404         >
01405         inline bool operator <= ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
01406         {
01407             return !( GetImpl( rhs ) < GetImpl( *this ) );
01408         }
01409
01410         // Ambiguity buster
01411         template
01412         <
01413             typename T1,
01414             template <class> class OP1,
01415             class CP1,
01416             template <class> class KP1,
01417             template <class> class SP1,
01418             template <class> class CNP1
01419         >
01420         inline bool operator >= ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
01421         {
01422             return !( GetImpl( *this ) < GetImpl( rhs ) );
01423         }
01424
01425     private:
01426         // Helper for enabling 'if (sp)'
01427         struct Tester
01428         {
01429             Tester(int) {}
01430             void dummy() {}
01431         };
01432
01433         typedef void (Tester::*unspecified_boolean_type_)();
01434
01435         typedef typename Select<CP::allow, Tester, unspecified_boolean_type_>::Result
01436             unspecified_boolean_type;
01437
01438     public:
01439         // enable 'if (sp)'
01440         operator unspecified_boolean_type() const
01441         {
01442             return !*this ? 0 : &Tester::dummy;
01443         }
01444
01445     private:
01446         // Helper for disallowing automatic conversion
01447         struct Insipid
01448         {
01449             Insipid(PointerType) {}
01450         };
01451
01452         typedef typename Select<CP::allow, PointerType, Insipid>::Result
01453             AutomaticConversionResult;
01454
01455     public:
01456         operator AutomaticConversionResult() const
01457         { return GetImpl(*this); }
01458     };
01459
01460
01462 // friends
01464
01465 #ifndef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
01466
01467     template
01468     <
01469         typename T,
01470         template <class> class OP,
01471         class CP,
01472         template <class> class KP,
01473         template <class> class SP,
01474         template <class> class CNP
01475     >
01476     inline void Release(SmartPtr<T, OP, CP, KP, SP, CNP>& sp,
01477                         typename SP<T>::StoredType& p)
01478     {
01479       p = GetImplRef(sp);
01480       GetImplRef(sp) = SP<T>::Default();
01481     }
01482
01483     template
01484     <
01485         typename T,
01486         template <class> class OP,
01487         class CP,
01488         template <class> class KP,
01489         template <class> class SP,
01490         template <class> class CNP
01491     >
01492     inline void Reset(SmartPtr<T, OP, CP, KP, SP, CNP>& sp,
01493                       typename SP<T>::StoredType p)
01494     { SmartPtr<T, OP, CP, KP, SP, CNP>(p).Swap(sp); }
01495
01496 #endif
01497
01499 // free comparison operators for class template SmartPtr
01501
01506
01507     template
01508     <
01509         typename T,
01510         template <class> class OP,
01511         class CP,
01512         template <class> class KP,
01513         template <class> class SP,
01514         template <class> class CNP1,
01515         typename U
01516     >
01517     inline bool operator==(const SmartPtr<T, OP, CP, KP, SP, CNP1 >& lhs,
01518         U* rhs)
01519     { return GetImpl(lhs) == rhs; }
01520
01525
01526     template
01527     <
01528         typename T,
01529         template <class> class OP,
01530         class CP,
01531         template <class> class KP,
01532         template <class> class SP,
01533         template <class> class CNP1,
01534         typename U
01535     >
01536     inline bool operator==(U* lhs,
01537         const SmartPtr<T, OP, CP, KP, SP, CNP1 >& rhs)
01538     { return rhs == lhs; }
01539
01544
01545     template
01546     <
01547         typename T,
01548         template <class> class OP,
01549         class CP,
01550         template <class> class KP,
01551         template <class> class SP,
01552         template <class> class CNP,
01553         typename U
01554     >
01555     inline bool operator!=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
01556         U* rhs)
01557     { return !(lhs == rhs); }
01558
01563
01564     template
01565     <
01566         typename T,
01567         template <class> class OP,
01568         class CP,
01569         template <class> class KP,
01570         template <class> class SP,
01571         template <class> class CNP,
01572         typename U
01573     >
01574     inline bool operator!=(U* lhs,
01575         const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
01576     { return rhs != lhs; }
01577
01582
01583     template
01584     <
01585         typename T,
01586         template <class> class OP,
01587         class CP,
01588         template <class> class KP,
01589         template <class> class SP,
01590         template <class> class CNP,
01591         typename U
01592     >
01593     inline bool operator<(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
01594         U* rhs)
01595     {
01596         return ( GetImpl( lhs ) < rhs );
01597     }
01598
01603
01604     template
01605     <
01606         typename T,
01607         template <class> class OP,
01608         class CP,
01609         template <class> class KP,
01610         template <class> class SP,
01611         template <class> class CNP,
01612         typename U
01613     >
01614     inline bool operator<(U* lhs,
01615         const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
01616     {
01617         return ( GetImpl( rhs ) < lhs );
01618     }
01619
01621 //  operator> for lhs = SmartPtr, rhs = raw pointer
01624
01625     template
01626     <
01627         typename T,
01628         template <class> class OP,
01629         class CP,
01630         template <class> class KP,
01631         template <class> class SP,
01632         template <class> class CNP,
01633         typename U
01634     >
01635     inline bool operator>(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
01636         U* rhs)
01637     { return rhs < lhs; }
01638
01643
01644     template
01645     <
01646         typename T,
01647         template <class> class OP,
01648         class CP,
01649         template <class> class KP,
01650         template <class> class SP,
01651         template <class> class CNP,
01652         typename U
01653     >
01654     inline bool operator>(U* lhs,
01655         const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
01656     { return rhs < lhs; }
01657
01662
01663     template
01664     <
01665         typename T,
01666         template <class> class OP,
01667         class CP,
01668         template <class> class KP,
01669         template <class> class SP,
01670         template <class> class CNP,
01671         typename U
01672     >
01673     inline bool operator<=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
01674         U* rhs)
01675     { return !(rhs < lhs); }
01676
01681
01682     template
01683     <
01684         typename T,
01685         template <class> class OP,
01686         class CP,
01687         template <class> class KP,
01688         template <class> class SP,
01689         template <class> class CNP,
01690         typename U
01691     >
01692     inline bool operator<=(U* lhs,
01693         const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
01694     { return !(rhs < lhs); }
01695
01700
01701     template
01702     <
01703         typename T,
01704         template <class> class OP,
01705         class CP,
01706         template <class> class KP,
01707         template <class> class SP,
01708         template <class> class CNP,
01709         typename U
01710     >
01711     inline bool operator>=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
01712         U* rhs)
01713     { return !(lhs < rhs); }
01714
01719
01720     template
01721     <
01722         typename T,
01723         template <class> class OP,
01724         class CP,
01725         template <class> class KP,
01726         template <class> class SP,
01727         template <class> class CNP,
01728         typename U
01729     >
01730     inline bool operator>=(U* lhs,
01731         const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
01732     { return !(lhs < rhs); }
01733
01734 } // namespace Loki
01735
01740
01741 namespace std
01742 {
01743     template
01744     <
01745         typename T,
01746         template <class> class OP,
01747         class CP,
01748         template <class> class KP,
01749         template <class> class SP,
01750         template <class> class CNP
01751     >
01752     struct less< Loki::SmartPtr<T, OP, CP, KP, SP, CNP > >
01753         : public binary_function<Loki::SmartPtr<T, OP, CP, KP, SP, CNP >,
01754             Loki::SmartPtr<T, OP, CP, KP, SP, CNP >, bool>
01755     {
01756         bool operator()(const Loki::SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
01757             const Loki::SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) const
01758         { return less<T*>()(GetImpl(lhs), GetImpl(rhs)); }
01759     };
01760 }
01761
01762 #endif // end file guardian
01763
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: SPCachedFactory.h Source File

SPCachedFactory.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 by Guillaume Chatelet
00004 //
00005 // Code covered by the MIT License
00006 //
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 // purpose is hereby granted without fee, provided that the above copyright
00009 // notice appear in all copies and that both that copyright notice and this
00010 // permission notice appear in supporting documentation.
00011 //
00012 // The authors make no representations about the suitability of this software
00013 // for any purpose. It is provided "as is" without express or implied warranty.
00014 //
00015 // This code DOES NOT accompany the book:
00016 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00017 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00018 //
00020
00021 // $Id: SPCachedFactory.h 810 2007-02-25 14:36:28Z syntheticpp $
00022
00023 #ifndef SPCACHEDFACTORY_H_
00024 #define SPCACHEDFACTORY_H_
00025
00038 #include <loki/Functor.h>
00039 #include <loki/SmartPtr.h>
00040 #include <loki/CachedFactory.h>
00041
00042 namespace Loki
00043 {
00044
00060
00061     template <class T>
00062     class FunctionStorage
00063     {
00064     public:
00066         typedef T* StoredType;
00068         typedef T* InitPointerType;
00070         typedef T* PointerType;
00072         typedef T& ReferenceType;
00074         typedef Functor< void , Seq< void* > > FunctorType;
00075
00076         FunctionStorage() : pointee_(Default()), functor_()
00077         {}
00078
00079         // The storage policy doesn't initialize the stored pointer
00080         //     which will be initialized by the OwnershipPolicy's Clone fn
00081         FunctionStorage(const FunctionStorage& rsh) : pointee_(0), functor_(rsh.functor_)
00082         {}
00083
00084         template <class U>
00085         FunctionStorage(const FunctionStorage<U>& rsh) : pointee_(0), functor_(rsh.functor_)
00086         {}
00087
00088         FunctionStorage(const StoredType& p) : pointee_(p), functor_() {}
00089
00090         PointerType operator->() const { return pointee_; }
00091
00092         ReferenceType operator*() const { return *pointee_; }
00093
00094         void Swap(FunctionStorage& rhs)
00095         {
00096           std::swap(pointee_, rhs.pointee_);
00097           std::swap(functor_, rhs.functor_);
00098         }
00099
00102         void SetCallBackFunction(const FunctorType &functor)
00103         {
00104           functor_ = functor;
00105         }
00106
00107         // Accessors
00108         template <class F>
00109         friend typename FunctionStorage<F>::PointerType GetImpl(const FunctionStorage<F>& sp);
00110
00111         template <class F>
00112         friend const typename FunctionStorage<F>::StoredType& GetImplRef(const FunctionStorage<F>& sp);
00113
00114         template <class F>
00115         friend typename FunctionStorage<F>::StoredType& GetImplRef(FunctionStorage<F>& sp);
00116
00117     protected:
00118         // Destroys the data stored
00119         // (Destruction might be taken over by the OwnershipPolicy)
00120         void Destroy()
00121         {
00122             functor_(this);
00123         }
00124
00125         // Default value to initialize the pointer
00126         static StoredType Default()
00127         { return 0; }
00128
00129     private:
00130         // Data
00131         StoredType pointee_;
00132         FunctorType functor_;
00133     };
00134
00135     template <class T>
00136     inline typename FunctionStorage<T>::PointerType GetImpl(const FunctionStorage<T>& sp)
00137     { return sp.pointee_; }
00138
00139     template <class T>
00140     inline const typename FunctionStorage<T>::StoredType& GetImplRef(const FunctionStorage<T>& sp)
00141     { return sp.pointee_; }
00142
00143     template <class T>
00144     inline typename FunctionStorage<T>::StoredType& GetImplRef(FunctionStorage<T>& sp)
00145     { return sp.pointee_; }
00146
00157      template
00158      <
00159           class AbstractProduct,
00160           template <class> class OwnershipPolicy = RefCounted,
00161         class ConversionPolicy = DisallowConversion,
00162         template <class> class CheckingPolicy = AssertCheck,
00163         template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
00164      >
00165      class SmartPointer
00166      {
00167      private:
00168              typedef SmartPtr< AbstractProduct,OwnershipPolicy,
00169                ConversionPolicy, CheckingPolicy,
00170                FunctionStorage, ConstnessPolicy > CallBackSP;
00171      protected:
00172            typedef CallBackSP ProductReturn;
00173            SmartPointer() : fun(this, &SmartPointer::smartPointerCallbackFunction) {}
00174            virtual ~SmartPointer(){};
00175
00176            ProductReturn encapsulate(AbstractProduct* pProduct)
00177            {
00178                     CallBackSP SP(pProduct);
00179                     SP.SetCallBackFunction(fun);
00180                 return SP;
00181            }
00182
00183            AbstractProduct* release(ProductReturn &pProduct)
00184            {
00185                 return GetImpl(pProduct);
00186            }
00187
00188            const char* name(){return "smart pointer";}
00189
00190      private:
00191            SmartPointer& operator=(const SmartPointer&);
00192            SmartPointer(const SmartPointer&);
00193              void smartPointerCallbackFunction(void* pSP)
00194              {
00195                     CallBackSP &SP(*reinterpret_cast<CallBackSP*>(pSP));
00196                     ReleaseObject(SP);
00197              }
00198            virtual void ReleaseObject(ProductReturn &object)=0;
00199            const typename CallBackSP::FunctorType fun;
00200      };
00201
00202 } // namespace Loki
00203
00204 #endif /*SPCACHEDFACTORY_H_*/
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: static_check.h Source File

static_check.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_STATIC_CHECK_INC_
00016 #define LOKI_STATIC_CHECK_INC_
00017
00018 // $Id: static_check.h 752 2006-10-17 19:52:18Z syntheticpp $
00019
00020
00021 namespace Loki
00022 {
00024 // Helper structure for the STATIC_CHECK macro
00026
00027     template<int> struct CompileTimeError;
00028     template<> struct CompileTimeError<true> {};
00029 }
00030
00032 // macro STATIC_CHECK
00033 // Invocation: STATIC_CHECK(expr, id)
00034 // where:
00035 // expr is a compile-time integral or pointer expression
00036 // id is a C++ identifier that does not need to be defined
00037 // If expr is zero, id will appear in a compile-time error message.
00039
00040 #define LOKI_STATIC_CHECK(expr, msg) \
00041     { Loki::CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; }
00042
00043
00044 #endif // end file guardian
00045
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: StrongPtr.cpp Source File

StrongPtr.cpp

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 Rich Sposato
00004 // Permission to use, copy, modify, distribute and sell this software for any
00005 //     purpose is hereby granted without fee, provided that the above copyright
00006 //     notice appear in all copies and that both that copyright notice and this
00007 //     permission notice appear in supporting documentation.
00008 // The author makes no representations about the
00009 //     suitability of this software for any purpose. It is provided "as is"
00010 //     without express or implied warranty.
00012
00013 // $Id: StrongPtr.cpp 807 2007-02-25 12:49:19Z syntheticpp $
00014
00015
00016 #include <loki/StrongPtr.h>
00017
00018 #include <memory.h>
00019 #ifdef DO_EXTRA_LOKI_TESTS
00020     #include <cassert>
00021 #endif
00022
00023 #include <loki/SmallObj.h>
00024
00025
00026 // ----------------------------------------------------------------------------
00027
00028 namespace Loki
00029 {
00030
00031 // ----------------------------------------------------------------------------
00032
00033 TwoRefCounts::TwoRefCounts( bool strong )
00034     : m_counts( NULL )
00035 {
00036     void * temp = SmallObject<>::operator new(
00037         sizeof(Loki::Private::TwoRefCountInfo) );
00038 #ifdef DO_EXTRA_LOKI_TESTS
00039     assert( temp != 0 );
00040 #endif
00041     m_counts = new ( temp ) Loki::Private::TwoRefCountInfo( strong );
00042 }
00043
00044 // ----------------------------------------------------------------------------
00045
00046 TwoRefCounts::TwoRefCounts( const void * p, bool strong )
00047     : m_counts( NULL )
00048 {
00049     void * temp = SmallObject<>::operator new(
00050         sizeof(Loki::Private::TwoRefCountInfo) );
00051 #ifdef DO_EXTRA_LOKI_TESTS
00052     assert( temp != 0 );
00053 #endif
00054     void * p2 = const_cast< void * >( p );
00055     m_counts = new ( temp ) Loki::Private::TwoRefCountInfo( p2, strong );
00056 }
00057
00058 // ----------------------------------------------------------------------------
00059
00060 void TwoRefCounts::Increment( bool strong )
00061 {
00062     if ( strong )
00063     {
00064         m_counts->IncStrongCount();
00065     }
00066     else
00067     {
00068         m_counts->IncWeakCount();
00069     }
00070 }
00071
00072 // ----------------------------------------------------------------------------
00073
00074 bool TwoRefCounts::Decrement( bool strong )
00075 {
00076     if ( strong )
00077     {
00078         m_counts->DecStrongCount();
00079     }
00080     else
00081     {
00082         m_counts->DecWeakCount();
00083     }
00084     return !m_counts->HasStrongPointer();
00085 }
00086
00087 // ----------------------------------------------------------------------------
00088
00089 void TwoRefCounts::Swap( TwoRefCounts & rhs )
00090 {
00091     std::swap( m_counts, rhs.m_counts );
00092 }
00093
00094 // ----------------------------------------------------------------------------
00095
00096 void TwoRefCounts::ZapPointer( void )
00097 {
00098 #ifdef DO_EXTRA_LOKI_TESTS
00099     assert( !m_counts->HasStrongPointer() );
00100 #endif
00101     if ( m_counts->HasWeakPointer() )
00102     {
00103         m_counts->ZapPointer();
00104     }
00105     else
00106     {
00107         SmallObject<>::operator delete ( m_counts,
00108             sizeof(Loki::Private::TwoRefCountInfo) );
00109         m_counts = NULL;
00110     }
00111 }
00112
00113
00114 // ----------------------------------------------------------------------------
00115
00116 TwoRefLinks::TwoRefLinks( const void * p, bool strong )
00117     : m_pointer( const_cast< void * >( p ) )
00118     , m_strong( strong )
00119 {
00120     m_prev = m_next = this;
00121 #ifdef DO_EXTRA_LOKI_TESTS
00122     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00123 #endif
00124 }
00125
00126 // ----------------------------------------------------------------------------
00127
00128 TwoRefLinks::TwoRefLinks( const TwoRefLinks & rhs, bool strong )
00129     : m_pointer( rhs.m_pointer )
00130     , m_prev( const_cast< TwoRefLinks * >( &rhs ) )
00131     , m_next( rhs.m_next )
00132     , m_strong( strong )
00133 {
00134     m_prev->m_next = this;
00135     m_next->m_prev = this;
00136
00137 #ifdef DO_EXTRA_LOKI_TESTS
00138     assert( m_prev->HasPrevNode( this ) );
00139     assert( m_next->HasNextNode( this ) );
00140     assert( rhs.m_next->HasNextNode( this ) );
00141     assert( rhs.m_prev->HasPrevNode( this ) );
00142     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00143     assert( CountPrevCycle( this ) == CountNextCycle( &rhs ) );
00144     assert( AllNodesHaveSamePointer() );
00145 #endif
00146 }
00147
00148 // ----------------------------------------------------------------------------
00149
00150 void TwoRefLinks::SetPointer( void * p )
00151 {
00152     TwoRefLinks * node = m_prev;
00153     if ( ( this == node ) || ( 0 == node ) )
00154         return;
00155
00156 #ifdef DO_EXTRA_LOKI_TESTS
00157     assert( m_prev->HasPrevNode( this ) );
00158     assert( m_next->HasNextNode( this ) );
00159     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00160     assert( AllNodesHaveSamePointer() );
00161 #endif
00162
00163     while ( node != this )
00164     {
00165         node->m_pointer = p;
00166         node = node->m_next;
00167     }
00168     m_pointer = node;
00169
00170 #ifdef DO_EXTRA_LOKI_TESTS
00171     assert( m_prev->HasPrevNode( this ) );
00172     assert( m_next->HasNextNode( this ) );
00173     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00174     assert( AllNodesHaveSamePointer() );
00175 #endif
00176 }
00177
00178 // ----------------------------------------------------------------------------
00179
00180 bool TwoRefLinks::Release( bool strong )
00181 {
00182
00183     (void)strong;
00184 #ifdef DO_EXTRA_LOKI_TESTS
00185     assert( strong == m_strong );
00186     assert( m_prev->HasPrevNode( this ) );
00187     assert( m_next->HasNextNode( this ) );
00188     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00189     assert( AllNodesHaveSamePointer() );
00190 #endif
00191
00192     if ( NULL == m_next )
00193     {
00194 #ifdef DO_EXTRA_LOKI_TESTS
00195         assert( NULL == m_prev );
00196 #endif
00197         // Return false so it does not try to destroy shared object
00198         // more than once.
00199         return false;
00200     }
00201     else if (m_next == this)
00202     {
00203 #ifdef DO_EXTRA_LOKI_TESTS
00204         assert(m_prev == this);
00205 #endif
00206         // Set these to NULL to prevent re-entrancy.
00207         m_prev = NULL;
00208         m_next = NULL;
00209         // Last one in the cycle has to release the pointer.
00210         return true;
00211     }
00212
00213 #ifdef DO_EXTRA_LOKI_TESTS
00214     assert( this != m_prev );
00215     assert( NULL != m_prev );
00216     assert( m_prev->HasPrevNode( this ) );
00217     assert( m_next->HasNextNode( this ) );
00218 #endif
00219
00220     // If a single node is strong, then return false so it won't release.
00221     if ( HasStrongPointer() )
00222     {
00223         // A cyclic chain of pointers is only as strong as the strongest link.
00224         m_prev->m_next = m_next;
00225         m_next->m_prev = m_prev;
00226         return false;
00227     }
00228
00229     return true;
00230 }
00231
00232 // ----------------------------------------------------------------------------
00233
00234 void TwoRefLinks::ZapAllNodes( void )
00235 {
00236     TwoRefLinks * p = m_prev;
00237     if ( ( this == p ) || ( 0 == p ) )
00238         return;
00239 #ifdef DO_EXTRA_LOKI_TESTS
00240     assert( AllNodesHaveSamePointer() );
00241 #endif
00242
00243     while ( p != this )
00244     {
00245         TwoRefLinks * p1 = p->m_prev;
00246         p->m_pointer = 0;
00247         p->m_next = p;
00248         p->m_prev = p;
00249         p = p1;
00250     }
00251     m_pointer = 0;
00252 }
00253
00254 // ----------------------------------------------------------------------------
00255
00256 void TwoRefLinks::Swap( TwoRefLinks & rhs )
00257 {
00258
00259 #ifdef DO_EXTRA_LOKI_TESTS
00260     assert( m_prev->HasPrevNode( this ) );
00261     assert( m_next->HasNextNode( this ) );
00262     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00263     assert( AllNodesHaveSamePointer() );
00264     assert( rhs.AllNodesHaveSamePointer() );
00265 #endif
00266
00267     std::swap( rhs.m_pointer, m_pointer );
00268     if (m_next == this)
00269     {
00270 #ifdef DO_EXTRA_LOKI_TESTS
00271         // This is in a cycle by itself.
00272         assert(m_prev == this);
00273 #endif
00274         if (rhs.m_next == &rhs)
00275         {
00276 #ifdef DO_EXTRA_LOKI_TESTS
00277             assert(rhs.m_prev == &rhs);
00278 #endif
00279             // both are in 1-node cycles - thus there is nothing to do.
00280             return;
00281         }
00282         m_prev = rhs.m_prev;
00283         m_next = rhs.m_next;
00284         m_prev->m_next = m_next->m_prev = this;
00285         rhs.m_next = rhs.m_prev = &rhs;
00286         return;
00287     }
00288     if (rhs.m_next == &rhs)
00289     {
00290 #ifdef DO_EXTRA_LOKI_TESTS
00291         // rhs is in a cycle by itself.
00292         assert( rhs.m_prev == &rhs );
00293 #endif
00294         rhs.m_prev = m_prev;
00295         rhs.m_next = m_next;
00296         m_prev->m_next = m_next->m_prev = &rhs;
00297         m_next = m_prev = this;
00298         return;
00299     }
00300     if (m_next == &rhs ) // rhs is next neighbour
00301     {
00302         if ( m_prev == &rhs )
00303             return;  // cycle of 2 pointers - no need to swap.
00304         std::swap(m_prev, m_next);
00305         std::swap(rhs.m_prev, rhs.m_next);
00306         std::swap(rhs.m_prev, m_next);
00307         std::swap(rhs.m_prev->m_next,m_next->m_prev);
00308     }
00309     else if ( m_prev == &rhs ) // rhs is prev neighbor
00310     {
00311         if ( m_next == &rhs )
00312             return;  // cycle of 2 pointers - no need to swap.
00313         std::swap( m_prev, m_next );
00314         std::swap( rhs.m_next, rhs.m_prev );
00315         std::swap( rhs.m_next, m_prev );
00316         std::swap( rhs.m_next->m_prev, m_prev->m_next );
00317     }
00318     else // not neighhbors
00319     {
00320         std::swap(m_prev, rhs.m_prev);
00321         std::swap(m_next, rhs.m_next);
00322         std::swap(m_prev->m_next, rhs.m_prev->m_next);
00323         std::swap(m_next->m_prev, rhs.m_next->m_prev);
00324     }
00325
00326 #ifdef DO_EXTRA_LOKI_TESTS
00327     assert( m_next == this ? m_prev == this : m_prev != this);
00328     assert( m_prev == this ? m_next == this : m_next != this);
00329     assert( m_prev->HasPrevNode( this ) );
00330     assert( m_next->HasNextNode( this ) );
00331     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00332     assert( rhs.m_prev->HasPrevNode( &rhs ) );
00333     assert( rhs.m_next->HasNextNode( &rhs ) );
00334     assert( CountPrevCycle( &rhs ) == CountNextCycle( &rhs ) );
00335     assert( AllNodesHaveSamePointer() );
00336     assert( rhs.AllNodesHaveSamePointer() );
00337 #endif
00338
00339 }
00340
00341 // ----------------------------------------------------------------------------
00342
00343 bool TwoRefLinks::AllNodesHaveSamePointer( void ) const
00344 {
00345     const TwoRefLinks * next = m_next;
00346     if ( NULL == next )
00347         return true;
00348     do
00349     {
00350         if ( next->m_pointer != m_pointer )
00351             return false;
00352         next = next->m_next;
00353     } while ( next != this );
00354     return true;
00355 }
00356
00357 // ----------------------------------------------------------------------------
00358
00359 unsigned int TwoRefLinks::CountPrevCycle( const TwoRefLinks * pThis )
00360 {
00361     if ( NULL == pThis )
00362         return 0;
00363     const TwoRefLinks * p = pThis->m_prev;
00364     if ( NULL == p )
00365         return 0;
00366     if ( pThis == p )
00367         return 1;
00368
00369     unsigned int count = 1;
00370     do
00371     {
00372         p = p->m_prev;
00373         ++count;
00374     } while ( p != pThis );
00375
00376     return count;
00377 }
00378
00379 // ----------------------------------------------------------------------------
00380
00381 unsigned int TwoRefLinks::CountNextCycle( const TwoRefLinks * pThis )
00382 {
00383     if ( NULL == pThis )
00384         return 0;
00385     const TwoRefLinks * p = pThis->m_next;
00386     if ( NULL == p )
00387         return 0;
00388     if ( pThis == p )
00389         return 1;
00390
00391     unsigned int count = 1;
00392     while ( p != pThis )
00393     {
00394         p = p->m_next;
00395         ++count;
00396     }
00397
00398     return count;
00399 }
00400
00401 // ----------------------------------------------------------------------------
00402
00403 bool TwoRefLinks::HasPrevNode( const TwoRefLinks * p ) const
00404 {
00405     if ( this == p )
00406         return true;
00407     const TwoRefLinks * prev = m_prev;
00408     if ( NULL == prev )
00409         return false;
00410     while ( prev != this )
00411     {
00412         if ( p == prev )
00413             return true;
00414         prev = prev->m_prev;
00415     }
00416     return false;
00417 }
00418
00419 // ----------------------------------------------------------------------------
00420
00421 bool TwoRefLinks::HasNextNode( const TwoRefLinks * p ) const
00422 {
00423     if ( this == p )
00424         return true;
00425     const TwoRefLinks * next = m_next;
00426     if ( NULL == next )
00427         return false;
00428     while ( next != this )
00429     {
00430         if ( p == next )
00431             return true;
00432         next = next->m_next;
00433     }
00434     return false;
00435 }
00436
00437 // ----------------------------------------------------------------------------
00438
00439 bool TwoRefLinks::HasStrongPointer( void ) const
00440 {
00441     const TwoRefLinks * next = m_next;
00442     if ( NULL == next )
00443         return false;
00444     while ( next != this )
00445     {
00446         if ( next->m_strong )
00447             return true;
00448         next = next->m_next;
00449     }
00450     return false;
00451 }
00452
00453 // ----------------------------------------------------------------------------
00454
00455 bool TwoRefLinks::Merge( TwoRefLinks & rhs )
00456 {
00457
00458     if ( NULL == m_next )
00459     {
00460 #ifdef DO_EXTRA_LOKI_TESTS
00461         assert( NULL == m_prev );
00462 #endif
00463         return false;
00464     }
00465     TwoRefLinks * prhs = &rhs;
00466     if ( prhs == this )
00467         return true;
00468     if ( NULL == prhs->m_next )
00469     {
00470 #ifdef DO_EXTRA_LOKI_TESTS
00471         assert( NULL == prhs->m_prev );
00472 #endif
00473         return true;
00474     }
00475
00476 #ifdef DO_EXTRA_LOKI_TESTS
00477     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00478     assert( CountPrevCycle( prhs ) == CountNextCycle( prhs ) );
00479 #endif
00480     // If rhs node is already in this cycle, then no need to merge.
00481     if ( HasPrevNode( &rhs ) )
00482     {
00483 #ifdef DO_EXTRA_LOKI_TESTS
00484         assert( HasNextNode( &rhs ) );
00485 #endif
00486         return true;
00487     }
00488
00489     if ( prhs == prhs->m_next )
00490     {
00492 #ifdef DO_EXTRA_LOKI_TESTS
00493         assert( prhs->m_prev == prhs );
00494 #endif
00495         prhs->m_prev = m_prev;
00496         prhs->m_next = this;
00497         m_prev->m_next = prhs;
00498         m_prev = prhs;
00499     }
00500     else if ( this == m_next )
00501     {
00503 #ifdef DO_EXTRA_LOKI_TESTS
00504         assert( m_prev == this );
00505 #endif
00506         m_prev = prhs->m_prev;
00507         m_next = prhs;
00508         prhs->m_prev->m_next = this;
00509         prhs->m_prev = this;
00510     }
00511     else
00512     {
00513         m_next->m_prev = prhs->m_prev;
00514         prhs->m_prev->m_next = m_prev;
00515         m_next = prhs;
00516         prhs->m_prev = this;
00517     }
00518
00519
00520 #ifdef DO_EXTRA_LOKI_TESTS
00521     assert( CountPrevCycle( this ) == CountNextCycle( this ) );
00522 #endif
00523
00524     return true;
00525 }
00526
00527 // ----------------------------------------------------------------------------
00528
00529 } // end namespace Loki
00530
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: StrongPtr.h Source File

StrongPtr.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2006 Rich Sposato
00004 // The copyright on this file is protected under the terms of the MIT license.
00005 //
00006 // Permission to use, copy, modify, distribute and sell this software for any
00007 //     purpose is hereby granted without fee, provided that the above copyright
00008 //     notice appear in all copies and that both that copyright notice and this
00009 //     permission notice appear in supporting documentation.
00010 // The author makes no representations about the
00011 //     suitability of this software for any purpose. It is provided "as is"
00012 //     without express or implied warranty.
00014 #ifndef LOKI_STRONG_PTR_INC_
00015 #define LOKI_STRONG_PTR_INC_
00016
00017 // $Id: StrongPtr.h 807 2007-02-25 12:49:19Z syntheticpp $
00018
00019
00020 #include <loki/SmartPtr.h>
00021 #if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
00022     #include <loki/Threads.h>
00023 #endif
00024
00025
00111
00112
00113 namespace Loki
00114 {
00115
00116
00125
00126 template < class P >
00127 class DeleteUsingFree
00128 {
00129 public:
00130     inline void static Delete( const P * p )
00131     {
00132         if ( 0 != p )
00133         {
00134             p->~P();
00135             ::free( p );
00136         }
00137     }
00138
00140     inline static P * Default( void )
00141     {
00142         return 0;
00143     }
00144
00145     inline void Swap( DeleteUsingFree & ) {}
00146 };
00147
00156
00157 template < class P >
00158 class DeleteNothing
00159 {
00160 public:
00161     inline static void Delete( const P * )
00162     {
00163         // Do nothing at all!
00164     }
00165
00166     inline static P * Default( void )
00167     {
00168         return 0;
00169     }
00170
00171     inline void Swap( DeleteNothing & ) {}
00172 };
00173
00181
00182 template < class P >
00183 class DeleteSingle
00184 {
00185 public:
00186     inline static void Delete( const P * p )
00187     {
00193         typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ];
00194         delete p;
00195     }
00196
00197     inline static P * Default( void )
00198     {
00199         return 0;
00200     }
00201
00202     inline void Swap( DeleteSingle & ) {}
00203 };
00204
00212
00213 template < class P >
00214 class DeleteArray
00215 {
00216 public:
00217     inline static void Delete( const P * p )
00218     {
00224         typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ];
00225         delete [] p;
00226     }
00227
00228     inline static P * Default( void )
00229     {
00230         return 0;
00231     }
00232
00233     inline void Swap( DeleteArray & ) {}
00234 };
00235
00244
00245 template < class P >
00246 struct CantResetWithStrong
00247 {
00248     inline bool OnReleaseAll( bool hasStrongPtr ) const
00249     {
00250         return ! hasStrongPtr;
00251     }
00252
00253     inline bool OnResetAll( bool hasStrongPtr ) const
00254     {
00255         return ! hasStrongPtr;
00256     }
00257 };
00258
00266
00267 template < class P >
00268 struct AllowReset
00269 {
00270     inline bool OnReleaseAll( bool ) const
00271     {
00272         return true;
00273     }
00274     inline bool OnResetAll( bool ) const
00275     {
00276         return true;
00277     }
00278 };
00279
00287
00288 template < class P >
00289 struct NeverReset
00290 {
00291     inline bool OnReleaseAll( bool ) const
00292     {
00293         return false;
00294     }
00295     inline bool OnResetAll( bool ) const
00296     {
00297         return false;
00298     }
00299 };
00300
00301 // ----------------------------------------------------------------------------
00302
00303 namespace Private
00304 {
00305
00317
00318 class LOKI_EXPORT TwoRefCountInfo
00319 {
00320 public:
00321
00322     inline explicit TwoRefCountInfo( bool strong )
00323         : m_pointer( 0 )
00324         , m_strongCount( strong ? 1 : 0 )
00325         , m_weakCount( strong ? 0 : 1 )
00326     {
00327     }
00328
00329     inline TwoRefCountInfo( void * p, bool strong )
00330         : m_pointer( p )
00331         , m_strongCount( strong ? 1 : 0 )
00332         , m_weakCount( strong ? 0 : 1 )
00333     {
00334     }
00335
00336     inline ~TwoRefCountInfo( void )
00337     {
00338         assert( 0 == m_strongCount );
00339         assert( 0 == m_weakCount );
00340     }
00341
00342     inline bool HasStrongPointer( void ) const
00343     {
00344         return ( 0 < m_strongCount );
00345     }
00346
00347     inline bool HasWeakPointer( void ) const
00348     {
00349         return ( 0 < m_weakCount );
00350     }
00351
00352     inline void IncStrongCount( void )
00353     {
00354         ++m_strongCount;
00355     }
00356
00357     inline void IncWeakCount( void )
00358     {
00359         ++m_weakCount;
00360     }
00361
00362     inline void DecStrongCount( void )
00363     {
00364         assert( 0 < m_strongCount );
00365         --m_strongCount;
00366     }
00367
00368     inline void DecWeakCount( void )
00369     {
00370         assert( 0 < m_weakCount );
00371         --m_weakCount;
00372     }
00373
00374     inline void ZapPointer( void )
00375     {
00376         m_pointer = 0;
00377     }
00378
00379     void SetPointer( void * p )
00380     {
00381         m_pointer = p;
00382     }
00383
00384     inline void * GetPointer( void ) const
00385     {
00386         return m_pointer;
00387     }
00388
00389     inline void * & GetPointerRef( void ) const
00390     {
00391         return const_cast< void * & >( m_pointer );
00392     }
00393
00394 private:
00396     TwoRefCountInfo( const TwoRefCountInfo & );
00398     TwoRefCountInfo & operator = ( const TwoRefCountInfo & );
00399
00400     void * m_pointer;
00401     unsigned int m_strongCount;
00402     unsigned int m_weakCount;
00403 };
00404
00422
00423 #if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
00424
00425 class LOKI_EXPORT LockableTwoRefCountInfo
00426     : private Loki::Private::TwoRefCountInfo
00427 {
00428 public:
00429
00430     inline explicit LockableTwoRefCountInfo( bool strong )
00431         : TwoRefCountInfo( strong )
00432         , m_Mutex()
00433     {
00434     }
00435
00436     LockableTwoRefCountInfo( void * p, bool strong )
00437         : TwoRefCountInfo( p, strong )
00438         , m_Mutex()
00439     {
00440     }
00441
00442     inline ~LockableTwoRefCountInfo( void )
00443     {
00444     }
00445
00446     inline void Lock( void ) const
00447     {
00448         m_Mutex.Lock();
00449     }
00450
00451     inline void Unlock( void ) const
00452     {
00453         m_Mutex.Unlock();
00454     }
00455
00456     inline bool HasStrongPointer( void ) const
00457     {
00458         m_Mutex.Lock();
00459         const bool has = TwoRefCountInfo::HasStrongPointer();
00460         m_Mutex.Unlock();
00461         return has;
00462     }
00463
00464     inline bool HasWeakPointer( void ) const
00465     {
00466         m_Mutex.Lock();
00467         const bool has = TwoRefCountInfo::HasWeakPointer();
00468         m_Mutex.Unlock();
00469         return has;
00470     }
00471
00472     inline void IncStrongCount( void )
00473     {
00474         m_Mutex.Lock();
00475         TwoRefCountInfo::IncStrongCount();
00476         m_Mutex.Unlock();
00477     }
00478
00479     inline void IncWeakCount( void )
00480     {
00481         m_Mutex.Lock();
00482         TwoRefCountInfo::IncWeakCount();
00483         m_Mutex.Unlock();
00484     }
00485
00486     inline void DecStrongCount( void )
00487     {
00488         m_Mutex.Lock();
00489         TwoRefCountInfo::DecStrongCount();
00490         m_Mutex.Unlock();
00491     }
00492
00493     inline void DecWeakCount( void )
00494     {
00495         m_Mutex.Lock();
00496         TwoRefCountInfo::DecWeakCount();
00497         m_Mutex.Unlock();
00498     }
00499
00500     inline void ZapPointer( void )
00501     {
00502         m_Mutex.Lock();
00503         TwoRefCountInfo::ZapPointer();
00504         m_Mutex.Unlock();
00505     }
00506
00507     void SetPointer( void * p )
00508     {
00509         m_Mutex.Lock();
00510         TwoRefCountInfo::SetPointer( p );
00511         m_Mutex.Unlock();
00512     }
00513
00514     inline void * GetPointer( void ) const
00515     {
00516         return TwoRefCountInfo::GetPointer();
00517     }
00518
00519     inline void * & GetPointerRef( void ) const
00520     {
00521         return TwoRefCountInfo::GetPointerRef();
00522     }
00523
00524 private:
00526     LockableTwoRefCountInfo( void );
00528     LockableTwoRefCountInfo( const LockableTwoRefCountInfo & );
00530     LockableTwoRefCountInfo & operator = ( const LockableTwoRefCountInfo & );
00531
00532     mutable LOKI_DEFAULT_MUTEX m_Mutex;
00533 };
00534
00535 #endif // if object-level-locking or class-level-locking
00536
00537 } // end namespace Private
00538
00549
00550 class LOKI_EXPORT TwoRefCounts
00551 {
00552 protected:
00553
00554     explicit TwoRefCounts( bool strong );
00555
00556     TwoRefCounts( const void * p, bool strong );
00557
00558     TwoRefCounts( const TwoRefCounts & rhs, bool strong ) :
00559         m_counts( rhs.m_counts )
00560     {
00561         Increment( strong );
00562     }
00563
00564     inline bool Release( bool strong )
00565     {
00566         return Decrement( strong );
00567     }
00568
00569     void Increment( bool strong );
00570
00571     bool Decrement( bool strong );
00572
00573     bool HasStrongPointer( void ) const
00574     {
00575         return m_counts->HasStrongPointer();
00576     }
00577
00578     void Swap( TwoRefCounts & rhs );
00579
00580     void SetPointer( void * p )
00581     {
00582         m_counts->SetPointer( p );
00583     }
00584
00585     void ZapPointer( void );
00586
00587     inline void * & GetPointerRef( void ) const
00588     {
00589         return m_counts->GetPointerRef();
00590     }
00591
00592     inline void * GetPointer( void ) const
00593     {
00594         return m_counts->GetPointer();
00595     }
00596
00597 private:
00598     TwoRefCounts( void );
00599     TwoRefCounts & operator = ( const TwoRefCounts & );
00600
00602     Loki::Private::TwoRefCountInfo * m_counts;
00603 };
00604
00619
00620 #if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
00621
00622 class LOKI_EXPORT LockableTwoRefCounts
00623 {
00624     typedef SmallValueObject< ::Loki::ClassLevelLockable > ThreadSafePointerAllocator;
00625
00626 protected:
00627
00628     explicit LockableTwoRefCounts( bool strong )
00629         : m_counts( NULL )
00630     {
00631         void * temp = ThreadSafePointerAllocator::operator new(
00632             sizeof(Loki::Private::LockableTwoRefCountInfo) );
00633 #ifdef DO_EXTRA_LOKI_TESTS
00634         assert( temp != 0 );
00635 #endif
00636         m_counts = new ( temp ) Loki::Private::LockableTwoRefCountInfo( strong );
00637     }
00638
00639     LockableTwoRefCounts( const void * p, bool strong )
00640         : m_counts( NULL )
00641     {
00642         void * temp = ThreadSafePointerAllocator::operator new(
00643             sizeof(Loki::Private::LockableTwoRefCountInfo) );
00644 #ifdef DO_EXTRA_LOKI_TESTS
00645         assert( temp != 0 );
00646 #endif
00647         void * p2 = const_cast< void * >( p );
00648         m_counts = new ( temp )
00649             Loki::Private::LockableTwoRefCountInfo( p2, strong );
00650     }
00651
00652     LockableTwoRefCounts( const LockableTwoRefCounts & rhs, bool strong ) :
00653         m_counts( rhs.m_counts )
00654     {
00655         Increment( strong );
00656     }
00657
00658     inline void Lock( void ) const
00659     {
00660         m_counts->Lock();
00661     }
00662
00663     inline void Unlock( void ) const
00664     {
00665         m_counts->Unlock();
00666     }
00667
00668     inline bool Release( bool strong )
00669     {
00670         return Decrement( strong );
00671     }
00672
00673     void Increment( bool strong )
00674     {
00675         if ( strong )
00676         {
00677             m_counts->IncStrongCount();
00678         }
00679         else
00680         {
00681             m_counts->IncWeakCount();
00682         }
00683     }
00684
00685     bool Decrement( bool strong )
00686     {
00687         if ( strong )
00688         {
00689             m_counts->DecStrongCount();
00690         }
00691         else
00692         {
00693             m_counts->DecWeakCount();
00694         }
00695         return !m_counts->HasStrongPointer();
00696     }
00697
00698     bool HasStrongPointer( void ) const
00699     {
00700         return m_counts->HasStrongPointer();
00701     }
00702
00703     void Swap( LockableTwoRefCounts & rhs )
00704     {
00705         std::swap( m_counts, rhs.m_counts );
00706     }
00707
00708     void SetPointer( void * p )
00709     {
00710         m_counts->SetPointer( p );
00711     }
00712
00713     void ZapPointer( void )
00714     {
00715 #ifdef DO_EXTRA_LOKI_TESTS
00716         assert( !m_counts->HasStrongPointer() );
00717 #endif
00718         if ( m_counts->HasWeakPointer() )
00719         {
00720             m_counts->ZapPointer();
00721         }
00722         else
00723         {
00724             ThreadSafePointerAllocator::operator delete ( m_counts,
00725                 sizeof(Loki::Private::LockableTwoRefCountInfo) );
00726             m_counts = NULL;
00727         }
00728     }
00729
00730     inline void * GetPointer( void ) const
00731     {
00732         return m_counts->GetPointer();
00733     }
00734
00735     inline void * & GetPointerRef( void ) const
00736     {
00737         return m_counts->GetPointerRef();
00738     }
00739
00740 private:
00741     LockableTwoRefCounts( void );
00742     LockableTwoRefCounts & operator = ( const LockableTwoRefCounts & );
00743
00745     Loki::Private::LockableTwoRefCountInfo * m_counts;
00746 };
00747
00748 #endif // if object-level-locking or class-level-locking
00749
00759
00760 class LOKI_EXPORT TwoRefLinks
00761 {
00762 protected:
00763
00764     inline explicit TwoRefLinks( bool strong )
00765         : m_pointer( 0 )
00766         , m_strong( strong )
00767     {
00768         m_prev = m_next = this;
00769     }
00770
00771     TwoRefLinks( const void * p, bool strong );
00772
00773     TwoRefLinks( const TwoRefLinks & rhs, bool strong );
00774
00775     bool Release( bool strong );
00776
00777     void Swap( TwoRefLinks & rhs );
00778
00779     bool Merge( TwoRefLinks & rhs );
00780
00781     bool HasStrongPointer( void ) const;
00782
00783     inline void ZapPointer( void )
00784     {
00785         ZapAllNodes();
00786     }
00787
00788     void SetPointer( void * p );
00789
00790     inline void * GetPointer( void ) const
00791     {
00792         return m_pointer;
00793     }
00794
00795     inline void * & GetPointerRef( void ) const
00796     {
00797         return const_cast< void * & >( m_pointer );
00798     }
00799
00800 private:
00801     static unsigned int CountPrevCycle( const TwoRefLinks * pThis );
00802     static unsigned int CountNextCycle( const TwoRefLinks * pThis );
00803
00805     TwoRefLinks( void );
00807     TwoRefLinks & operator = ( const TwoRefLinks & );
00808
00809     bool HasPrevNode( const TwoRefLinks * p ) const;
00810     bool HasNextNode( const TwoRefLinks * p ) const;
00811     bool AllNodesHaveSamePointer( void ) const;
00812     void ZapAllNodes( void );
00813
00814     void * m_pointer;
00815     mutable TwoRefLinks * m_prev;
00816     mutable TwoRefLinks * m_next;
00817     const bool m_strong;
00818 };
00819
00833
00834 template
00835 <
00836     typename T,
00837     bool Strong = true,
00838     class OwnershipPolicy = Loki::TwoRefCounts,
00839     class ConversionPolicy = Loki::DisallowConversion,
00840     template < class > class CheckingPolicy = Loki::AssertCheck,
00841     template < class > class ResetPolicy = Loki::CantResetWithStrong,
00842     template < class > class DeletePolicy = Loki::DeleteSingle,
00843     template < class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
00844 >
00845 class StrongPtr
00846     : public OwnershipPolicy
00847     , public ConversionPolicy
00848     , public CheckingPolicy< T * >
00849     , public ResetPolicy< T >
00850     , public DeletePolicy< T >
00851 {
00852     typedef ConversionPolicy CP;
00853     typedef CheckingPolicy< T * > KP;
00854     typedef ResetPolicy< T > RP;
00855     typedef DeletePolicy< T > DP;
00856
00857 public:
00858
00859     typedef OwnershipPolicy OP;
00860
00861     typedef T * StoredType;    // the type of the pointer
00862     typedef T * PointerType;   // type returned by operator->
00863     typedef T & ReferenceType; // type returned by operator*
00864
00865     typedef typename ConstnessPolicy< T >::Type * ConstPointerType;
00866     typedef typename ConstnessPolicy< T >::Type & ConstReferenceType;
00867
00868 private:
00869     struct NeverMatched {};
00870
00871 #ifdef LOKI_SMARTPTR_CONVERSION_CONSTRUCTOR_POLICY
00872     typedef typename Select< CP::allow, const StoredType&, NeverMatched>::Result ImplicitArg;
00873     typedef typename Select<!CP::allow, const StoredType&, NeverMatched>::Result ExplicitArg;
00874 #else
00875     typedef const StoredType& ImplicitArg;
00876     typedef typename Select<false, const StoredType&, NeverMatched>::Result ExplicitArg;
00877 #endif
00878
00879 public:
00880
00881     StrongPtr( void ) : OP( Strong )
00882     {
00883         KP::OnDefault( GetPointer() );
00884     }
00885
00886     explicit StrongPtr( ExplicitArg p ) : OP( p, Strong )
00887     {
00888         KP::OnInit( GetPointer() );
00889     }
00890
00891     StrongPtr( ImplicitArg p ) : OP( p, Strong )
00892     {
00893         KP::OnInit( GetPointer() );
00894     }
00895
00896     StrongPtr( const StrongPtr & rhs )
00897         : OP( rhs, Strong ), CP( rhs ), KP( rhs ), DP( rhs )
00898     {
00899     }
00900
00901     template
00902     <
00903         typename T1,
00904         bool S1,
00905         class OP1,
00906         class CP1,
00907         template < class > class KP1,
00908         template < class > class RP1,
00909         template < class > class DP1,
00910         template < class > class CNP1
00911     >
00912     StrongPtr(
00913         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
00914         : OP( rhs, Strong )
00915     {
00916     }
00917
00918     template
00919     <
00920         typename T1,
00921         bool S1,
00922         class OP1,
00923         class CP1,
00924         template < class > class KP1,
00925         template < class > class RP1,
00926         template < class > class DP1,
00927         template < class > class CNP1
00928     >
00929     StrongPtr(
00930         StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
00931         : OP( rhs, Strong )
00932     {
00933     }
00934
00935     StrongPtr( RefToValue< StrongPtr > rhs )
00936         : OP( rhs, Strong ), KP( rhs ), CP( rhs ), DP( rhs )
00937     {
00938     }
00939
00940     operator RefToValue< StrongPtr >( void )
00941     {
00942         return RefToValue< StrongPtr >( *this );
00943     }
00944
00945     StrongPtr & operator = ( const StrongPtr & rhs )
00946     {
00947         if ( GetPointer() != rhs.GetPointer() )
00948         {
00949             StrongPtr temp( rhs );
00950             temp.Swap( *this );
00951         }
00952         return *this;
00953     }
00954
00955     StrongPtr & operator = ( T * p )
00956     {
00957         if ( GetPointer() != p )
00958         {
00959             StrongPtr temp( p );
00960             Swap( temp );
00961         }
00962         return *this;
00963     }
00964
00965     template
00966     <
00967         typename T1,
00968         bool S1,
00969         class OP1,
00970         class CP1,
00971         template < class > class KP1,
00972         template < class > class RP1,
00973         template < class > class DP1,
00974         template < class > class CNP1
00975     >
00976     StrongPtr & operator = (
00977         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
00978     {
00979         if ( !rhs.Equals( GetPointer() ) )
00980         {
00981             StrongPtr temp( rhs );
00982             temp.Swap( *this );
00983         }
00984         return *this;
00985     }
00986
00987     bool IsStrong( void ) const
00988     {
00989         return Strong;
00990     }
00991
00992     void Swap( StrongPtr & rhs )
00993     {
00994         OP::Swap( rhs );
00995         CP::Swap( rhs );
00996         KP::Swap( rhs );
00997         DP::Swap( rhs );
00998     }
00999
01000     ~StrongPtr()
01001     {
01002         if ( OP::Release( Strong ) )
01003         {
01004             // Must zap the pointer before deleteing the object. Otherwise a
01005             // cycle of weak pointers will lead to recursion, which leads to
01006             // to deleting the shared object multiple times, which leads to
01007             // undefined behavior.  Therefore, this must get pointer before
01008             // zapping it, and then delete the temp pointer.
01009             T * p = GetPointer();
01010             if ( p != 0 )
01011             {
01012                 OP::ZapPointer();
01013                 DP::Delete( p );
01014             }
01015         }
01016     }
01017
01018 #ifdef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
01019
01020     // old non standard in class definition of friends
01021     friend bool ReleaseAll( StrongPtr & sp,
01022         typename StrongPtr::StoredType & p )
01023     {
01024         if ( !sp.RP::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
01025         {
01026             return false;
01027         }
01028         p = sp.GetPointer();
01029         sp.OP::SetPointer( sp.DP::Default() );
01030         return true;
01031     }
01032
01033     friend bool ResetAll( StrongPtr & sp,
01034         typename StrongPtr::StoredType p )
01035     {
01036         if ( sp.OP::GetPointer() == p )
01037         {
01038             return true;
01039         }
01040         if ( !sp.RP::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
01041         {
01042             return false;
01043         }
01044         sp.DP::Delete( sp.GetPointer() );
01045         sp.OP::SetPointer( p );
01046         return true;
01047     }
01048
01049 #else
01050
01051     template
01052     <
01053         typename T1,
01054         bool S1,
01055         class OP1,
01056         class CP1,
01057         template < class > class KP1,
01058         template < class > class RP1,
01059         template < class > class DP1,
01060         template < class > class CNP1
01061     >
01062     friend bool ReleaseAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp,
01063         typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType & p );
01064
01065
01066     template
01067     <
01068         typename T1,
01069         bool S1,
01070         class OP1,
01071         class CP1,
01072         template < class > class KP1,
01073         template < class > class RP1,
01074         template < class > class DP1,
01075         template < class > class CNP1
01076     >
01077     friend bool ResetAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp,
01078         typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType p );
01079
01080 #endif
01081
01082
01087     template
01088     <
01089         typename T1,
01090         bool S1,
01091         class OP1,
01092         class CP1,
01093         template < class > class KP1,
01094         template < class > class RP1,
01095         template < class > class DP1,
01096         template < class > class CNP1
01097     >
01098     bool Merge( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
01099     {
01100         if ( OP::GetPointer() != rhs.OP::GetPointer() )
01101         {
01102             return false;
01103         }
01104         return OP::Merge( rhs );
01105     }
01106
01110     void Lock( void )
01111     {
01112         OP::Lock();
01113     }
01114
01118     void Unlock( void )
01119     {
01120         OP::Unlock();
01121     }
01122
01123     PointerType operator -> ()
01124     {
01125         KP::OnDereference( GetPointer() );
01126         return GetPointer();
01127     }
01128
01129     ConstPointerType operator -> () const
01130     {
01131         KP::OnDereference( GetPointer() );
01132         return GetPointer();
01133     }
01134
01135     ReferenceType operator * ()
01136     {
01137         KP::OnDereference( GetPointer() );
01138         return * GetPointer();
01139     }
01140
01141     ConstReferenceType operator * () const
01142     {
01143         KP::OnDereference( GetPointer() );
01144         return * GetPointer();
01145     }
01146
01148     template < class T1 >
01149     bool Equals( const T1 * p ) const
01150     {
01151         return ( GetPointer() == p );
01152     }
01153
01155     template < class T1 >
01156     bool LessThan( const T1 * p ) const
01157     {
01158         return ( GetPointer() < p );
01159     }
01160
01162     template < class T1 >
01163     bool GreaterThan( const T1 * p ) const
01164     {
01165         return ( GetPointer() > p );
01166     }
01167
01169     template
01170     <
01171         typename T1,
01172         bool S1,
01173         class OP1,
01174         class CP1,
01175         template < class > class KP1,
01176         template < class > class RP1,
01177         template < class > class DP1,
01178         template < class > class CNP1
01179     >
01180     bool operator == (
01181         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
01182     {
01183         return ( rhs.Equals( GetPointer() ) );
01184     }
01185
01187     template
01188     <
01189         typename T1,
01190         bool S1,
01191         class OP1,
01192         class CP1,
01193         template < class > class KP1,
01194         template < class > class RP1,
01195         template < class > class DP1,
01196         template < class > class CNP1
01197     >
01198     bool operator != (
01199         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
01200     {
01201         return !( rhs.Equals( GetPointer() ) );
01202     }
01203
01205     template
01206     <
01207         typename T1,
01208         bool S1,
01209         class OP1,
01210         class CP1,
01211         template < class > class KP1,
01212         template < class > class RP1,
01213         template < class > class DP1,
01214         template < class > class CNP1
01215     >
01216     bool operator < (
01217         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
01218     {
01219         return ( rhs.GreaterThan( GetPointer() ) );
01220     }
01221
01223     template
01224     <
01225         typename T1,
01226         bool S1,
01227         class OP1,
01228         class CP1,
01229         template < class > class KP1,
01230         template < class > class RP1,
01231         template < class > class DP1,
01232         template < class > class CNP1
01233     >
01234     inline bool operator > (
01235         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
01236     {
01237         return ( rhs.LessThan( GetPointer() ) );
01238     }
01239
01241     template
01242     <
01243         typename T1,
01244         bool S1,
01245         class OP1,
01246         class CP1,
01247         template < class > class KP1,
01248         template < class > class RP1,
01249         template < class > class DP1,
01250         template < class > class CNP1
01251     >
01252     inline bool operator <= (
01253         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
01254     {
01255         return !( rhs.LessThan( GetPointer() ) );
01256     }
01257
01259     template
01260     <
01261         typename T1,
01262         bool S1,
01263         class OP1,
01264         class CP1,
01265         template < class > class KP1,
01266         template < class > class RP1,
01267         template < class > class DP1,
01268         template < class > class CNP1
01269     >
01270     inline bool operator >= (
01271         const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
01272     {
01273         return !( rhs.GreaterThan( GetPointer() ) );
01274     }
01275
01276     inline bool operator ! () const // Enables "if ( !sp ) ..."
01277     {
01278         return ( 0 == OP::GetPointer() );
01279     }
01280
01281 protected:
01282
01283     inline PointerType GetPointer( void )
01284     {
01285         return reinterpret_cast< PointerType >( OP::GetPointer() );
01286     }
01287
01288     inline ConstPointerType GetPointer( void ) const
01289     {
01290         return reinterpret_cast< ConstPointerType >( OP::GetPointer() );
01291     }
01292
01293 private:
01294
01295     inline ReferenceType GetPointerRef( void )
01296     {
01297         return reinterpret_cast< ReferenceType >( OP::GetPointerRef() );
01298     }
01299
01300     inline ConstReferenceType GetPointerRef( void ) const
01301     {
01302         return reinterpret_cast< ConstReferenceType >( OP::GetPointerRef() );
01303     }
01304
01305     // Helper for enabling 'if (sp)'
01306     struct Tester
01307     {
01308         Tester(int) {}
01309         void dummy() {}
01310     };
01311
01312     typedef void (Tester::*unspecified_boolean_type_)();
01313
01314     typedef typename Select< CP::allow, Tester, unspecified_boolean_type_ >::Result
01315         unspecified_boolean_type;
01316
01317 public:
01318     // enable 'if (sp)'
01319     operator unspecified_boolean_type() const
01320     {
01321         return !*this ? 0 : &Tester::dummy;
01322     }
01323
01324 private:
01325     // Helper for disallowing automatic conversion
01326     struct Insipid
01327     {
01328         Insipid(PointerType) {}
01329     };
01330
01331     typedef typename Select< CP::allow, PointerType, Insipid >::Result
01332         AutomaticConversionResult;
01333
01334 public:
01335     operator AutomaticConversionResult() const
01336     {
01337         return GetPointer();
01338     }
01339
01340 };
01341
01342 // ----------------------------------------------------------------------------
01343
01344 // friend functions
01345
01346 #ifndef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
01347
01348 template
01349 <
01350     typename U,
01351     typename T,
01352     bool S,
01353     class OP,
01354     class CP,
01355     template < class > class KP,
01356     template < class > class RP,
01357     template < class > class DP,
01358     template < class > class CNP
01359 >
01360 bool ReleaseAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp,
01361                  typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType & p )
01362 {
01363   if ( !sp.RP<T>::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
01364   {
01365     return false;
01366   }
01367   p = sp.GetPointer();
01368   sp.OP::SetPointer( sp.DP<T>::Default() );
01369   return true;
01370 }
01371
01372 template
01373 <
01374     typename U,
01375     typename T,
01376     bool S,
01377     class OP,
01378     class CP,
01379     template < class > class KP,
01380     template < class > class RP,
01381     template < class > class DP,
01382     template < class > class CNP
01383 >
01384 bool ResetAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp,
01385                typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType p )
01386 {
01387   if ( sp.OP::GetPointer() == p )
01388   {
01389     return true;
01390   }
01391   if ( !sp.RP<T>::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
01392   {
01393     return false;
01394   }
01395   sp.DP<T>::Delete( sp.GetPointer() );
01396   sp.OP::SetPointer( p );
01397   return true;
01398 }
01399 #endif
01400
01401
01402 // free comparison operators for class template StrongPtr
01403
01406 template
01407 <
01408     typename U,
01409     typename T,
01410     bool S,
01411     class OP,
01412     class CP,
01413     template < class > class KP,
01414     template < class > class RP,
01415     template < class > class DP,
01416     template < class > class CNP
01417 >
01418 inline bool operator == (
01419     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs )
01420 {
01421     return ( lhs.Equals( rhs ) );
01422 }
01423
01426 template
01427 <
01428     typename U,
01429     typename T,
01430     bool S,
01431     class OP,
01432     class CP,
01433     template < class > class KP,
01434     template < class > class RP,
01435     template < class > class DP,
01436     template < class > class CNP
01437 >
01438 inline bool operator == ( U * lhs,
01439     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
01440 {
01441     return ( rhs.Equals( lhs ) );
01442 }
01443
01446 template
01447 <
01448     typename U,
01449     typename T,
01450     bool S,
01451     class OP,
01452     class CP,
01453     template < class > class KP,
01454     template < class > class RP,
01455     template < class > class DP,
01456     template < class > class CNP
01457 >
01458 inline bool operator != (
01459     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs )
01460 {
01461     return !( lhs.Equals( rhs ) );
01462 }
01463
01466 template
01467 <
01468     typename U,
01469     typename T,
01470     bool S,
01471     class OP,
01472     class CP,
01473     template < class > class KP,
01474     template < class > class RP,
01475     template < class > class DP,
01476     template < class > class CNP
01477 >
01478 inline bool operator != ( U * lhs,
01479     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
01480 {
01481     return !( rhs.Equals( lhs ) );
01482 }
01483
01486 template
01487 <
01488     typename U,
01489     typename T,
01490     bool S,
01491     class OP,
01492     class CP,
01493     template < class > class KP,
01494     template < class > class RP,
01495     template < class > class DP,
01496     template < class > class CNP
01497 >
01498 inline bool operator < (
01499     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs )
01500 {
01501     return ( lhs.LessThan( rhs ) );
01502 }
01503
01506 template
01507 <
01508     typename U,
01509     typename T,
01510     bool S,
01511     class OP,
01512     class CP,
01513     template < class > class KP,
01514     template < class > class RP,
01515     template < class > class DP,
01516     template < class > class CNP
01517 >
01518 inline bool operator < ( U * lhs,
01519     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
01520 {
01521     return ( rhs.GreaterThan( lhs ) );
01522 }
01523
01524 //  operator> for lhs = StrongPtr, rhs = raw pointer
01526 template
01527 <
01528     typename U,
01529     typename T,
01530     bool S,
01531     class OP,
01532     class CP,
01533     template < class > class KP,
01534     template < class > class RP,
01535     template < class > class DP,
01536     template < class > class CNP
01537 >
01538 inline bool operator > (
01539     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs )
01540 {
01541     return ( lhs.GreaterThan( rhs ) );
01542 }
01543
01546 template
01547 <
01548     typename U,
01549     typename T,
01550     bool S,
01551     class OP,
01552     class CP,
01553     template < class > class KP,
01554     template < class > class RP,
01555     template < class > class DP,
01556     template < class > class CNP
01557 >
01558 inline bool operator > ( U * lhs,
01559     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
01560 {
01561     return ( rhs.LessThan( lhs ) );
01562 }
01563
01566 template
01567 <
01568     typename U,
01569     typename T,
01570     bool S,
01571     class OP,
01572     class CP,
01573     template < class > class KP,
01574     template < class > class RP,
01575     template < class > class DP,
01576     template < class > class CNP
01577 >
01578 inline bool operator <= (
01579     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs )
01580 {
01581     return !( lhs.GreaterThan( rhs ) );
01582 }
01583
01586 template
01587 <
01588     typename U,
01589     typename T,
01590     bool S,
01591     class OP,
01592     class CP,
01593     template < class > class KP,
01594     template < class > class RP,
01595     template < class > class DP,
01596     template < class > class CNP
01597 >
01598 inline bool operator <= ( U * lhs,
01599     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
01600 {
01601     return !( rhs.LessThan( lhs ) );
01602 }
01603
01606 template
01607 <
01608     typename U,
01609     typename T,
01610     bool S,
01611     class OP,
01612     class CP,
01613     template < class > class KP,
01614     template < class > class RP,
01615     template < class > class DP,
01616     template < class > class CNP
01617 >
01618 inline bool operator >= (
01619     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs )
01620 {
01621     return !( lhs.LessThan( rhs ) );
01622 }
01623
01626 template
01627 <
01628     typename U,
01629     typename T,
01630     bool S,
01631     class OP,
01632     class CP,
01633     template < class > class KP,
01634     template < class > class RP,
01635     template < class > class DP,
01636     template < class > class CNP
01637 >
01638 inline bool operator >= ( U * lhs,
01639     const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
01640 {
01641     return !( rhs.GreaterThan( lhs ) );
01642 }
01643
01644 } // namespace Loki
01645
01646 namespace std
01647 {
01652     template
01653     <
01654         typename T,
01655         bool S,
01656         class OP,
01657         class CP,
01658         template < class > class KP,
01659         template < class > class RP,
01660         template < class > class DP,
01661         template < class > class CNP
01662     >
01663     struct less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
01664         : public binary_function<
01665             Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >,
01666             Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >, bool >
01667     {
01668         bool operator () (
01669             const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs,
01670             const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) const
01671         {
01672             return ( lhs < rhs );
01673         }
01674     };
01675 }
01676
01678
01679 #endif // end file guardian
01680
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Threads.h Source File

Threads.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_THREADS_INC_
00016 #define LOKI_THREADS_INC_
00017
00018 // $Id: Threads.h 749 2006-10-17 19:49:26Z syntheticpp $
00019
00020
00051
00052
00053 #include <cassert>
00054
00055 #if defined(LOKI_CLASS_LEVEL_THREADING) || defined(LOKI_OBJECT_LEVEL_THREADING)
00056
00057     #define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::ClassLevelLockable
00058
00059     #if defined(LOKI_CLASS_LEVEL_THREADING) && !defined(LOKI_OBJECT_LEVEL_THREADING)
00060         #define LOKI_DEFAULT_THREADING ::Loki::ClassLevelLockable
00061     #else
00062         #define LOKI_DEFAULT_THREADING ::Loki::ObjectLevelLockable
00063     #endif
00064
00065     #if defined(_WIN32) || defined(_WIN64)
00066         #include <windows.h>
00067         #define LOKI_WINDOWS_H
00068     #else
00069         #include <pthread.h>
00070         #define LOKI_PTHREAD_H
00071     #endif
00072
00073 #else
00074
00075     #define LOKI_DEFAULT_THREADING ::Loki::SingleThreaded
00076     #define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::SingleThreaded
00077
00078 #endif
00079
00080 #ifndef LOKI_DEFAULT_MUTEX
00081 #define LOKI_DEFAULT_MUTEX ::Loki::Mutex
00082 #endif
00083
00084 #ifdef LOKI_WINDOWS_H
00085
00086 #define LOKI_THREADS_MUTEX(x)           CRITICAL_SECTION (x);
00087 #define LOKI_THREADS_MUTEX_INIT(x)      ::InitializeCriticalSection (x)
00088 #define LOKI_THREADS_MUTEX_DELETE(x)    ::DeleteCriticalSection (x)
00089 #define LOKI_THREADS_MUTEX_LOCK(x)      ::EnterCriticalSection (x)
00090 #define LOKI_THREADS_MUTEX_UNLOCK(x)    ::LeaveCriticalSection (x)
00091 #define LOKI_THREADS_LONG               LONG
00092
00093 #define LOKI_THREADS_ATOMIC_FUNCTIONS                                   \
00094         static IntType AtomicIncrement(volatile IntType& lval)          \
00095         { return InterlockedIncrement(&const_cast<IntType&>(lval)); }   \
00096                                                                         \
00097         static IntType AtomicDecrement(volatile IntType& lval)          \
00098         { return InterlockedDecrement(&const_cast<IntType&>(lval)); }   \
00099                                                                         \
00100         static void AtomicAssign(volatile IntType& lval, IntType val)   \
00101         { InterlockedExchange(&const_cast<IntType&>(lval), val); }      \
00102                                                                         \
00103         static void AtomicAssign(IntType& lval, volatile IntType& val)  \
00104         { InterlockedExchange(&lval, val); }
00105
00106
00107
00108 #elif defined(LOKI_PTHREAD_H)
00109
00110
00111 #define LOKI_THREADS_MUTEX(x)           pthread_mutex_t (x);
00112
00113 // no recursive mutex support
00114 #define LOKI_THREADS_MUTEX_INIT(x)      ::pthread_mutex_init(x, 0)
00115
00116 #define LOKI_THREADS_MUTEX_DELETE(x)    ::pthread_mutex_destroy (x)
00117 #define LOKI_THREADS_MUTEX_LOCK(x)      ::pthread_mutex_lock (x)
00118 #define LOKI_THREADS_MUTEX_UNLOCK(x)    ::pthread_mutex_unlock (x)
00119 #define LOKI_THREADS_LONG               long
00120
00121 #define LOKI_THREADS_ATOMIC(x)                                           \
00122                 pthread_mutex_lock(&atomic_mutex_);                      \
00123                 x;                                                       \
00124                 pthread_mutex_unlock(&atomic_mutex_)
00125
00126 #define LOKI_THREADS_ATOMIC_FUNCTIONS                                    \
00127         private:                                                         \
00128             static pthread_mutex_t atomic_mutex_;                        \
00129         public:                                                          \
00130         static IntType AtomicIncrement(volatile IntType& lval)           \
00131         { LOKI_THREADS_ATOMIC( lval++ ); return lval; }                  \
00132                                                                          \
00133         static IntType AtomicDecrement(volatile IntType& lval)           \
00134         { LOKI_THREADS_ATOMIC(lval-- ); return lval; }                   \
00135                                                                          \
00136         static void AtomicAssign(volatile IntType& lval, IntType val)    \
00137         { LOKI_THREADS_ATOMIC( lval = val ); }                           \
00138                                                                          \
00139         static void AtomicAssign(IntType& lval, volatile IntType& val)   \
00140         { LOKI_THREADS_ATOMIC( lval = val ); }
00141
00142 #else // single threaded
00143
00144 #define LOKI_THREADS_MUTEX(x)
00145 #define LOKI_THREADS_MUTEX_INIT(x)
00146 #define LOKI_THREADS_MUTEX_DELETE(x)
00147 #define LOKI_THREADS_MUTEX_LOCK(x)
00148 #define LOKI_THREADS_MUTEX_UNLOCK(x)
00149 #define LOKI_THREADS_LONG
00150
00151 #endif
00152
00153
00154
00155 namespace Loki
00156 {
00157
00160     //
00164
00165     class Mutex
00166     {
00167     public:
00168         Mutex()
00169         {
00170             LOKI_THREADS_MUTEX_INIT(&mtx_);
00171         }
00172         ~Mutex()
00173         {
00174             LOKI_THREADS_MUTEX_DELETE(&mtx_);
00175         }
00176         void Lock()
00177         {
00178             LOKI_THREADS_MUTEX_LOCK(&mtx_);
00179         }
00180         void Unlock()
00181         {
00182             LOKI_THREADS_MUTEX_UNLOCK(&mtx_);
00183         }
00184     private:
00186         Mutex(const Mutex &);
00188         Mutex & operator = (const Mutex &);
00189         LOKI_THREADS_MUTEX(mtx_)
00190     };
00191
00192
00200     template <class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX>
00201     class SingleThreaded
00202     {
00203     public:
00206         struct Lock
00207         {
00208             Lock() {}
00209             explicit Lock(const SingleThreaded&) {}
00210             explicit Lock(const SingleThreaded*) {}
00211         };
00212
00213         typedef Host VolatileType;
00214
00215         typedef int IntType;
00216
00217         static IntType AtomicAdd(volatile IntType& lval, IntType val)
00218         { return lval += val; }
00219
00220         static IntType AtomicSubtract(volatile IntType& lval, IntType val)
00221         { return lval -= val; }
00222
00223         static IntType AtomicMultiply(volatile IntType& lval, IntType val)
00224         { return lval *= val; }
00225
00226         static IntType AtomicDivide(volatile IntType& lval, IntType val)
00227         { return lval /= val; }
00228
00229         static IntType AtomicIncrement(volatile IntType& lval)
00230         { return ++lval; }
00231
00232         static IntType AtomicDecrement(volatile IntType& lval)
00233         { return --lval; }
00234
00235         static void AtomicAssign(volatile IntType & lval, IntType val)
00236         { lval = val; }
00237
00238         static void AtomicAssign(IntType & lval, volatile IntType & val)
00239         { lval = val; }
00240     };
00241
00242
00243 #if defined(LOKI_WINDOWS_H) || defined(LOKI_PTHREAD_H)
00244
00252     template < class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX >
00253     class ObjectLevelLockable
00254     {
00255         mutable MutexPolicy mtx_;
00256
00257     public:
00258         ObjectLevelLockable() : mtx_() {}
00259
00260         ObjectLevelLockable(const ObjectLevelLockable&) : mtx_() {}
00261
00262         ~ObjectLevelLockable() {}
00263
00264         class Lock;
00265         friend class Lock;
00266
00269         class Lock
00270         {
00271         public:
00272
00274             explicit Lock(const ObjectLevelLockable& host) : host_(host)
00275             {
00276                 host_.mtx_.Lock();
00277             }
00278
00280             explicit Lock(const ObjectLevelLockable* host) : host_(*host)
00281             {
00282                 host_.mtx_.Lock();
00283             }
00284
00286             ~Lock()
00287             {
00288                 host_.mtx_.Unlock();
00289             }
00290
00291         private:
00293             Lock();
00294             Lock(const Lock&);
00295             Lock& operator=(const Lock&);
00296             const ObjectLevelLockable& host_;
00297         };
00298
00299         typedef volatile Host VolatileType;
00300
00301         typedef LOKI_THREADS_LONG IntType;
00302
00303         LOKI_THREADS_ATOMIC_FUNCTIONS
00304
00305     };
00306
00307 #ifdef LOKI_PTHREAD_H
00308     template <class Host, class MutexPolicy>
00309     pthread_mutex_t ObjectLevelLockable<Host, MutexPolicy>::atomic_mutex_ = PTHREAD_MUTEX_INITIALIZER;
00310 #endif
00311
00319     template <class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX >
00320     class ClassLevelLockable
00321     {
00322         struct Initializer
00323         {
00324             bool init_;
00325             MutexPolicy mtx_;
00326
00327             Initializer() : init_(false), mtx_()
00328             {
00329                 init_ = true;
00330             }
00331
00332             ~Initializer()
00333             {
00334                 assert(init_);
00335             }
00336         };
00337
00338         static Initializer initializer_;
00339
00340     public:
00341
00342         class Lock;
00343         friend class Lock;
00344
00347         class Lock
00348         {
00349         public:
00350
00352             Lock()
00353             {
00354                 assert(initializer_.init_);
00355                 initializer_.mtx_.Lock();
00356             }
00357
00359             explicit Lock(const ClassLevelLockable&)
00360             {
00361                 assert(initializer_.init_);
00362                 initializer_.mtx_.Lock();
00363             }
00364
00366             explicit Lock(const ClassLevelLockable*)
00367             {
00368                 assert(initializer_.init_);
00369                 initializer_.mtx_.Lock();
00370             }
00371
00373             ~Lock()
00374             {
00375                 assert(initializer_.init_);
00376                 initializer_.mtx_.Unlock();
00377             }
00378
00379         private:
00380             Lock(const Lock&);
00381             Lock& operator=(const Lock&);
00382         };
00383
00384         typedef volatile Host VolatileType;
00385
00386         typedef LOKI_THREADS_LONG IntType;
00387
00388         LOKI_THREADS_ATOMIC_FUNCTIONS
00389
00390     };
00391
00392 #ifdef LOKI_PTHREAD_H
00393     template <class Host, class MutexPolicy>
00394     pthread_mutex_t ClassLevelLockable<Host, MutexPolicy>::atomic_mutex_ = PTHREAD_MUTEX_INITIALIZER;
00395 #endif
00396
00397     template < class Host, class MutexPolicy >
00398     typename ClassLevelLockable< Host, MutexPolicy >::Initializer
00399     ClassLevelLockable< Host, MutexPolicy >::initializer_;
00400
00401 #endif // #if defined(LOKI_WINDOWS_H) || defined(LOKI_PTHREAD_H)
00402
00403 } // namespace Loki
00404
00405
00406 #endif // end file guardian
00407
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Tuple.h Source File

Tuple.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015
00016 // Last update: June 20, 2001
00017
00019 // This file is intentionally left empty
00020 // Due to compiler limitations, its contents has been moved to
00021 //     HierarchyGenerators.h
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Typelist.h Source File

Typelist.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Welsey Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_TYPELIST_INC_
00016 #define LOKI_TYPELIST_INC_
00017
00018 // $Id: Typelist.h 749 2006-10-17 19:49:26Z syntheticpp $
00019
00020
00021 #include "NullType.h"
00022 #include "TypeManip.h"
00023 #include "TypelistMacros.h"
00024
00025
00026 namespace Loki
00027 {
00029 // class template Typelist
00030 // The building block of typelists of any length
00031 // Use it through the LOKI_TYPELIST_NN macros
00032 // Defines nested types:
00033 //     Head (first element, a non-typelist type by convention)
00034 //     Tail (second element, can be another typelist)
00036
00037     template <class T, class U>
00038     struct Typelist
00039     {
00040        typedef T Head;
00041        typedef U Tail;
00042     };
00043
00044 // Typelist utility algorithms
00045
00046     namespace TL
00047     {
00048
00050 // class template MakeTypelist
00051 // Takes a number of arguments equal to its numeric suffix
00052 // The arguments are type names.
00053 // MakeTypelist<T1, T2, ...>::Result
00054 // returns a typelist that is of T1, T2, ...
00056
00057         template
00058         <
00059             typename T1  = NullType, typename T2  = NullType, typename T3  = NullType,
00060             typename T4  = NullType, typename T5  = NullType, typename T6  = NullType,
00061             typename T7  = NullType, typename T8  = NullType, typename T9  = NullType,
00062             typename T10 = NullType, typename T11 = NullType, typename T12 = NullType,
00063             typename T13 = NullType, typename T14 = NullType, typename T15 = NullType,
00064             typename T16 = NullType, typename T17 = NullType, typename T18 = NullType
00065         >
00066         struct MakeTypelist
00067         {
00068         private:
00069             typedef typename MakeTypelist
00070             <
00071                 T2 , T3 , T4 ,
00072                 T5 , T6 , T7 ,
00073                 T8 , T9 , T10,
00074                 T11, T12, T13,
00075                 T14, T15, T16,
00076                 T17, T18
00077             >
00078             ::Result TailResult;
00079
00080         public:
00081             typedef Typelist<T1, TailResult> Result;
00082         };
00083
00084         template<>
00085         struct MakeTypelist<>
00086         {
00087             typedef NullType Result;
00088         };
00089
00091 // class template Length
00092 // Computes the length of a typelist
00093 // Invocation (TList is a typelist):
00094 // Length<TList>::value
00095 // returns a compile-time constant containing the length of TList, not counting
00096 //     the end terminator (which by convention is NullType)
00098
00099         template <class TList> struct Length;
00100         template <> struct Length<NullType>
00101         {
00102             enum { value = 0 };
00103         };
00104
00105         template <class T, class U>
00106         struct Length< Typelist<T, U> >
00107         {
00108             enum { value = 1 + Length<U>::value };
00109         };
00110
00112 // class template TypeAt
00113 // Finds the type at a given index in a typelist
00114 // Invocation (TList is a typelist and index is a compile-time integral
00115 //     constant):
00116 // TypeAt<TList, index>::Result
00117 // returns the type in position 'index' in TList
00118 // If you pass an out-of-bounds index, the result is a compile-time error
00120
00121         template <class TList, unsigned int index> struct TypeAt;
00122
00123         template <class Head, class Tail>
00124         struct TypeAt<Typelist<Head, Tail>, 0>
00125         {
00126             typedef Head Result;
00127         };
00128
00129         template <class Head, class Tail, unsigned int i>
00130         struct TypeAt<Typelist<Head, Tail>, i>
00131         {
00132             typedef typename TypeAt<Tail, i - 1>::Result Result;
00133         };
00134
00136 // class template TypeAtNonStrict
00137 // Finds the type at a given index in a typelist
00138 // Invocations (TList is a typelist and index is a compile-time integral
00139 //     constant):
00140 // a) TypeAt<TList, index>::Result
00141 // returns the type in position 'index' in TList, or NullType if index is
00142 //     out-of-bounds
00143 // b) TypeAt<TList, index, D>::Result
00144 // returns the type in position 'index' in TList, or D if index is out-of-bounds
00146
00147         template <class TList, unsigned int index,
00148             typename DefaultType = NullType>
00149         struct TypeAtNonStrict
00150         {
00151             typedef DefaultType Result;
00152         };
00153
00154         template <class Head, class Tail, typename DefaultType>
00155         struct TypeAtNonStrict<Typelist<Head, Tail>, 0, DefaultType>
00156         {
00157             typedef Head Result;
00158         };
00159
00160         template <class Head, class Tail, unsigned int i, typename DefaultType>
00161         struct TypeAtNonStrict<Typelist<Head, Tail>, i, DefaultType>
00162         {
00163             typedef typename
00164                 TypeAtNonStrict<Tail, i - 1, DefaultType>::Result Result;
00165         };
00166
00168 // class template IndexOf
00169 // Finds the index of a type in a typelist
00170 // Invocation (TList is a typelist and T is a type):
00171 // IndexOf<TList, T>::value
00172 // returns the position of T in TList, or NullType if T is not found in TList
00174
00175         template <class TList, class T> struct IndexOf;
00176
00177         template <class T>
00178         struct IndexOf<NullType, T>
00179         {
00180             enum { value = -1 };
00181         };
00182
00183         template <class T, class Tail>
00184         struct IndexOf<Typelist<T, Tail>, T>
00185         {
00186             enum { value = 0 };
00187         };
00188
00189         template <class Head, class Tail, class T>
00190         struct IndexOf<Typelist<Head, Tail>, T>
00191         {
00192         private:
00193             enum { temp = IndexOf<Tail, T>::value };
00194         public:
00195             enum { value = (temp == -1 ? -1 : 1 + temp) };
00196         };
00197
00199 // class template Append
00200 // Appends a type or a typelist to another
00201 // Invocation (TList is a typelist and T is either a type or a typelist):
00202 // Append<TList, T>::Result
00203 // returns a typelist that is TList followed by T and NullType-terminated
00205
00206         template <class TList, class T> struct Append;
00207
00208         template <> struct Append<NullType, NullType>
00209         {
00210             typedef NullType Result;
00211         };
00212
00213         template <class T> struct Append<NullType, T>
00214         {
00215             typedef Typelist<T,NullType> Result;
00216         };
00217
00218         template <class Head, class Tail>
00219         struct Append<NullType, Typelist<Head, Tail> >
00220         {
00221             typedef Typelist<Head, Tail> Result;
00222         };
00223
00224         template <class Head, class Tail, class T>
00225         struct Append<Typelist<Head, Tail>, T>
00226         {
00227             typedef Typelist<Head,
00228                     typename Append<Tail, T>::Result>
00229                 Result;
00230         };
00231
00233 // class template Erase
00234 // Erases the first occurence, if any, of a type in a typelist
00235 // Invocation (TList is a typelist and T is a type):
00236 // Erase<TList, T>::Result
00237 // returns a typelist that is TList without the first occurence of T
00239
00240         template <class TList, class T> struct Erase;
00241
00242         template <class T>                         // Specialization 1
00243         struct Erase<NullType, T>
00244         {
00245             typedef NullType Result;
00246         };
00247
00248         template <class T, class Tail>             // Specialization 2
00249         struct Erase<Typelist<T, Tail>, T>
00250         {
00251             typedef Tail Result;
00252         };
00253
00254         template <class Head, class Tail, class T> // Specialization 3
00255         struct Erase<Typelist<Head, Tail>, T>
00256         {
00257             typedef Typelist<Head,
00258                     typename Erase<Tail, T>::Result>
00259                 Result;
00260         };
00261
00263 // class template EraseAll
00264 // Erases all first occurences, if any, of a type in a typelist
00265 // Invocation (TList is a typelist and T is a type):
00266 // EraseAll<TList, T>::Result
00267 // returns a typelist that is TList without any occurence of T
00269
00270         template <class TList, class T> struct EraseAll;
00271         template <class T>
00272         struct EraseAll<NullType, T>
00273         {
00274             typedef NullType Result;
00275         };
00276         template <class T, class Tail>
00277         struct EraseAll<Typelist<T, Tail>, T>
00278         {
00279             // Go all the way down the list removing the type
00280             typedef typename EraseAll<Tail, T>::Result Result;
00281         };
00282         template <class Head, class Tail, class T>
00283         struct EraseAll<Typelist<Head, Tail>, T>
00284         {
00285             // Go all the way down the list removing the type
00286             typedef Typelist<Head,
00287                     typename EraseAll<Tail, T>::Result>
00288                 Result;
00289         };
00290
00292 // class template NoDuplicates
00293 // Removes all duplicate types in a typelist
00294 // Invocation (TList is a typelist):
00295 // NoDuplicates<TList, T>::Result
00297
00298         template <class TList> struct NoDuplicates;
00299
00300         template <> struct NoDuplicates<NullType>
00301         {
00302             typedef NullType Result;
00303         };
00304
00305         template <class Head, class Tail>
00306         struct NoDuplicates< Typelist<Head, Tail> >
00307         {
00308         private:
00309             typedef typename NoDuplicates<Tail>::Result L1;
00310             typedef typename Erase<L1, Head>::Result L2;
00311         public:
00312             typedef Typelist<Head, L2> Result;
00313         };
00314
00316 // class template Replace
00317 // Replaces the first occurence of a type in a typelist, with another type
00318 // Invocation (TList is a typelist, T, U are types):
00319 // Replace<TList, T, U>::Result
00320 // returns a typelist in which the first occurence of T is replaced with U
00322
00323         template <class TList, class T, class U> struct Replace;
00324
00325         template <class T, class U>
00326         struct Replace<NullType, T, U>
00327         {
00328             typedef NullType Result;
00329         };
00330
00331         template <class T, class Tail, class U>
00332         struct Replace<Typelist<T, Tail>, T, U>
00333         {
00334             typedef Typelist<U, Tail> Result;
00335         };
00336
00337         template <class Head, class Tail, class T, class U>
00338         struct Replace<Typelist<Head, Tail>, T, U>
00339         {
00340             typedef Typelist<Head,
00341                     typename Replace<Tail, T, U>::Result>
00342                 Result;
00343         };
00344
00346 // class template ReplaceAll
00347 // Replaces all occurences of a type in a typelist, with another type
00348 // Invocation (TList is a typelist, T, U are types):
00349 // Replace<TList, T, U>::Result
00350 // returns a typelist in which all occurences of T is replaced with U
00352
00353         template <class TList, class T, class U> struct ReplaceAll;
00354
00355         template <class T, class U>
00356         struct ReplaceAll<NullType, T, U>
00357         {
00358             typedef NullType Result;
00359         };
00360
00361         template <class T, class Tail, class U>
00362         struct ReplaceAll<Typelist<T, Tail>, T, U>
00363         {
00364             typedef Typelist<U, typename ReplaceAll<Tail, T, U>::Result> Result;
00365         };
00366
00367         template <class Head, class Tail, class T, class U>
00368         struct ReplaceAll<Typelist<Head, Tail>, T, U>
00369         {
00370             typedef Typelist<Head,
00371                     typename ReplaceAll<Tail, T, U>::Result>
00372                 Result;
00373         };
00374
00376 // class template Reverse
00377 // Reverses a typelist
00378 // Invocation (TList is a typelist):
00379 // Reverse<TList>::Result
00380 // returns a typelist that is TList reversed
00382
00383         template <class TList> struct Reverse;
00384
00385         template <>
00386         struct Reverse<NullType>
00387         {
00388             typedef NullType Result;
00389         };
00390
00391         template <class Head, class Tail>
00392         struct Reverse< Typelist<Head, Tail> >
00393         {
00394             typedef typename Append<
00395                 typename Reverse<Tail>::Result, Head>::Result Result;
00396         };
00397
00399 // class template MostDerived
00400 // Finds the type in a typelist that is the most derived from a given type
00401 // Invocation (TList is a typelist, T is a type):
00402 // MostDerived<TList, T>::Result
00403 // returns the type in TList that's the most derived from T
00405
00406         template <class TList, class T> struct MostDerived;
00407
00408         template <class T>
00409         struct MostDerived<NullType, T>
00410         {
00411             typedef T Result;
00412         };
00413
00414         template <class Head, class Tail, class T>
00415         struct MostDerived<Typelist<Head, Tail>, T>
00416         {
00417         private:
00418             typedef typename MostDerived<Tail, T>::Result Candidate;
00419         public:
00420             typedef typename Select<
00421                 SuperSubclass<Candidate,Head>::value,
00422                     Head, Candidate>::Result Result;
00423         };
00424
00426 // class template DerivedToFront
00427 // Arranges the types in a typelist so that the most derived types appear first
00428 // Invocation (TList is a typelist):
00429 // DerivedToFront<TList>::Result
00430 // returns the reordered TList
00432
00433         template <class TList> struct DerivedToFront;
00434
00435         template <>
00436         struct DerivedToFront<NullType>
00437         {
00438             typedef NullType Result;
00439         };
00440
00441         template <class Head, class Tail>
00442         struct DerivedToFront< Typelist<Head, Tail> >
00443         {
00444         private:
00445             typedef typename MostDerived<Tail, Head>::Result
00446                 TheMostDerived;
00447             typedef typename Replace<Tail,
00448                 TheMostDerived, Head>::Result Temp;
00449             typedef typename DerivedToFront<Temp>::Result L;
00450         public:
00451             typedef Typelist<TheMostDerived, L> Result;
00452         };
00453
00454     }   // namespace TL
00455 }   // namespace Loki
00456
00457
00458 #endif // end file guardian
00459
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: TypelistMacros.h Source File

TypelistMacros.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Welsey Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_TYPELISTMACROS_INC_
00016 #define LOKI_TYPELISTMACROS_INC_
00017
00018 // $Id: TypelistMacros.h 749 2006-10-17 19:49:26Z syntheticpp $
00019
00020
00021 //#define LOKI_DISABLE_TYPELIST_MACROS
00022 #ifndef LOKI_DISABLE_TYPELIST_MACROS
00023
00025 // macros LOKI_TYPELIST_1, LOKI_TYPELIST_2, ... LOKI_TYPELIST_50
00026 // Each takes a number of arguments equal to its numeric suffix
00027 // The arguments are type names. LOKI_TYPELIST_NN generates a typelist containing
00028 //     all types passed as arguments, in that order.
00029 // Example: LOKI_TYPELIST_2(char, int) generates a type containing char and int.
00031
00032 #define LOKI_TYPELIST_1(T1) ::Loki::Typelist<T1, ::Loki::NullType>
00033
00034 #define LOKI_TYPELIST_2(T1, T2) ::Loki::Typelist<T1, LOKI_TYPELIST_1(T2) >
00035
00036 #define LOKI_TYPELIST_3(T1, T2, T3) ::Loki::Typelist<T1, LOKI_TYPELIST_2(T2, T3) >
00037
00038 #define LOKI_TYPELIST_4(T1, T2, T3, T4) \
00039     ::Loki::Typelist<T1, LOKI_TYPELIST_3(T2, T3, T4) >
00040
00041 #define LOKI_TYPELIST_5(T1, T2, T3, T4, T5) \
00042     ::Loki::Typelist<T1, LOKI_TYPELIST_4(T2, T3, T4, T5) >
00043
00044 #define LOKI_TYPELIST_6(T1, T2, T3, T4, T5, T6) \
00045     ::Loki::Typelist<T1, LOKI_TYPELIST_5(T2, T3, T4, T5, T6) >
00046
00047 #define LOKI_TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) \
00048     ::Loki::Typelist<T1, LOKI_TYPELIST_6(T2, T3, T4, T5, T6, T7) >
00049
00050 #define LOKI_TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) \
00051     ::Loki::Typelist<T1, LOKI_TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >
00052
00053 #define LOKI_TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) \
00054     ::Loki::Typelist<T1, LOKI_TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >
00055
00056 #define LOKI_TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \
00057     ::Loki::Typelist<T1, LOKI_TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) >
00058
00059 #define LOKI_TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) \
00060     ::Loki::Typelist<T1, LOKI_TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
00061
00062 #define LOKI_TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) \
00063     ::Loki::Typelist<T1, LOKI_TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00064         T11, T12) >
00065
00066 #define LOKI_TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) \
00067     ::Loki::Typelist<T1, LOKI_TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00068         T11, T12, T13) >
00069
00070 #define LOKI_TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00071         T11, T12, T13, T14) \
00072     ::Loki::Typelist<T1, LOKI_TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00073         T11, T12, T13, T14) >
00074
00075 #define LOKI_TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00076         T11, T12, T13, T14, T15) \
00077     ::Loki::Typelist<T1, LOKI_TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00078         T11, T12, T13, T14, T15) >
00079
00080 #define LOKI_TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00081         T11, T12, T13, T14, T15, T16) \
00082     ::Loki::Typelist<T1, LOKI_TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00083         T11, T12, T13, T14, T15, T16) >
00084
00085 #define LOKI_TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00086         T11, T12, T13, T14, T15, T16, T17) \
00087     ::Loki::Typelist<T1, LOKI_TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00088         T11, T12, T13, T14, T15, T16, T17) >
00089
00090 #define LOKI_TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00091         T11, T12, T13, T14, T15, T16, T17, T18) \
00092     ::Loki::Typelist<T1, LOKI_TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00093         T11, T12, T13, T14, T15, T16, T17, T18) >
00094
00095 #define LOKI_TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00096         T11, T12, T13, T14, T15, T16, T17, T18, T19) \
00097     ::Loki::Typelist<T1, LOKI_TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00098         T11, T12, T13, T14, T15, T16, T17, T18, T19) >
00099
00100 #define LOKI_TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00101         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) \
00102     ::Loki::Typelist<T1, LOKI_TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00103         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) >
00104
00105 #define LOKI_TYPELIST_21(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00106         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) \
00107     ::Loki::Typelist<T1, LOKI_TYPELIST_20(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00108         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) >
00109
00110 #define LOKI_TYPELIST_22(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00111         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) \
00112     ::Loki::Typelist<T1, LOKI_TYPELIST_21(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00113         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) >
00114
00115 #define LOKI_TYPELIST_23(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00116         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) \
00117     ::Loki::Typelist<T1, LOKI_TYPELIST_22(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00118         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) >
00119
00120 #define LOKI_TYPELIST_24(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00121         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) \
00122     ::Loki::Typelist<T1, LOKI_TYPELIST_23(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00123         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) >
00124
00125 #define LOKI_TYPELIST_25(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00126         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) \
00127     ::Loki::Typelist<T1, LOKI_TYPELIST_24(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00128         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00129         T21, T22, T23, T24, T25) >
00130
00131 #define LOKI_TYPELIST_26(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00132         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00133         T21, T22, T23, T24, T25, T26) \
00134     ::Loki::Typelist<T1, LOKI_TYPELIST_25(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00135         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00136         T21, T22, T23, T24, T25, T26) >
00137
00138 #define LOKI_TYPELIST_27(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00139         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00140         T21, T22, T23, T24, T25, T26, T27) \
00141     ::Loki::Typelist<T1, LOKI_TYPELIST_26(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00142         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00143         T21, T22, T23, T24, T25, T26, T27) >
00144
00145 #define LOKI_TYPELIST_28(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00146         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00147         T21, T22, T23, T24, T25, T26, T27, T28) \
00148     ::Loki::Typelist<T1, LOKI_TYPELIST_27(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00149         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00150         T21, T22, T23, T24, T25, T26, T27, T28) >
00151
00152 #define LOKI_TYPELIST_29(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00153         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00154         T21, T22, T23, T24, T25, T26, T27, T28, T29) \
00155     ::Loki::Typelist<T1, LOKI_TYPELIST_28(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00156         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00157         T21, T22, T23, T24, T25, T26, T27, T28, T29) >
00158
00159 #define LOKI_TYPELIST_30(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00160         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00161         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) \
00162     ::Loki::Typelist<T1, LOKI_TYPELIST_29(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00163         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00164         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) >
00165
00166 #define LOKI_TYPELIST_31(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00167         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00168         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) \
00169     ::Loki::Typelist<T1, LOKI_TYPELIST_30(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00170         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00171         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) >
00172
00173 #define LOKI_TYPELIST_32(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00174         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00175         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) \
00176     ::Loki::Typelist<T1, LOKI_TYPELIST_31(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00177         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00178         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) >
00179
00180 #define LOKI_TYPELIST_33(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00181         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00182         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) \
00183     ::Loki::Typelist<T1, LOKI_TYPELIST_32(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00184         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00185         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) >
00186
00187 #define LOKI_TYPELIST_34(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00188         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00189         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) \
00190     ::Loki::Typelist<T1, LOKI_TYPELIST_33(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00191         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00192         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) >
00193
00194 #define LOKI_TYPELIST_35(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00195         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00196         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00197         T31, T32, T33, T34, T35) \
00198     ::Loki::Typelist<T1, LOKI_TYPELIST_34(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00199         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00200         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00201         T31, T32, T33, T34, T35) >
00202
00203 #define LOKI_TYPELIST_36(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00204         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00205         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00206         T31, T32, T33, T34, T35, T36) \
00207     ::Loki::Typelist<T1, LOKI_TYPELIST_35(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00208         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00209         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00210         T31, T32, T33, T34, T35, T36) >
00211
00212 #define LOKI_TYPELIST_37(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00213         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00214         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00215         T31, T32, T33, T34, T35, T36, T37) \
00216     ::Loki::Typelist<T1, LOKI_TYPELIST_36(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00217         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00218         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00219         T31, T32, T33, T34, T35, T36, T37) >
00220
00221 #define LOKI_TYPELIST_38(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00222         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00223         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00224         T31, T32, T33, T34, T35, T36, T37, T38) \
00225     ::Loki::Typelist<T1, LOKI_TYPELIST_37(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00226         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00227         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00228         T31, T32, T33, T34, T35, T36, T37, T38) >
00229
00230 #define LOKI_TYPELIST_39(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00231         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00232         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00233         T31, T32, T33, T34, T35, T36, T37, T38, T39) \
00234     ::Loki::Typelist<T1, LOKI_TYPELIST_38(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00235         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00236         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00237         T31, T32, T33, T34, T35, T36, T37, T38, T39) >
00238
00239 #define LOKI_TYPELIST_40(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00240         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00241         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00242         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) \
00243     ::Loki::Typelist<T1, LOKI_TYPELIST_39(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00244         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00245         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00246         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) >
00247
00248 #define LOKI_TYPELIST_41(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00249         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00250         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00251         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) \
00252     ::Loki::Typelist<T1, LOKI_TYPELIST_40(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00253         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00254         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00255         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) >
00256
00257 #define LOKI_TYPELIST_42(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00258         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00259         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00260         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) \
00261     ::Loki::Typelist<T1, LOKI_TYPELIST_41(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00262         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00263         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00264         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) >
00265
00266 #define LOKI_TYPELIST_43(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00267         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00268         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00269         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) \
00270     ::Loki::Typelist<T1, LOKI_TYPELIST_42(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00271         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00272         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00273         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) >
00274
00275 #define LOKI_TYPELIST_44(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00276         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00277         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00278         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) \
00279     ::Loki::Typelist<T1, LOKI_TYPELIST_43(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00280         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00281         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00282         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) >
00283
00284 #define LOKI_TYPELIST_45(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00285         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00286         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00287         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00288         T41, T42, T43, T44, T45) \
00289     ::Loki::Typelist<T1, LOKI_TYPELIST_44(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00290         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00291         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00292         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00293         T41, T42, T43, T44, T45) >
00294
00295 #define LOKI_TYPELIST_46(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00296         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00297         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00298         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00299         T41, T42, T43, T44, T45, T46) \
00300     ::Loki::Typelist<T1, LOKI_TYPELIST_45(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00301         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00302         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00303         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00304         T41, T42, T43, T44, T45, T46) >
00305
00306 #define LOKI_TYPELIST_47(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00307         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00308         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00309         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00310         T41, T42, T43, T44, T45, T46, T47) \
00311     ::Loki::Typelist<T1, LOKI_TYPELIST_46(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00312         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00313         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00314         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00315         T41, T42, T43, T44, T45, T46, T47) >
00316
00317 #define LOKI_TYPELIST_48(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00318         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00319         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00320         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00321         T41, T42, T43, T44, T45, T46, T47, T48) \
00322     ::Loki::Typelist<T1, LOKI_TYPELIST_47(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00323         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00324         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00325         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00326         T41, T42, T43, T44, T45, T46, T47, T48) >
00327
00328 #define LOKI_TYPELIST_49(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00329         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00330         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00331         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00332         T41, T42, T43, T44, T45, T46, T47, T48, T49) \
00333     ::Loki::Typelist<T1, LOKI_TYPELIST_48(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00334         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00335         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00336         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00337         T41, T42, T43, T44, T45, T46, T47, T48, T49) >
00338
00339 #define LOKI_TYPELIST_50(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00340         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00341         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00342         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00343         T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) \
00344     ::Loki::Typelist<T1, LOKI_TYPELIST_49(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
00345         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
00346         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
00347         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
00348         T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) >
00349
00350 #endif //LOKI_DISABLE_TYPELIST_MACROS
00351
00352 #endif // end file guardian
00353
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: TypeManip.h Source File

TypeManip.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Welsey Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_TYPEMANIP_INC_
00016 #define LOKI_TYPEMANIP_INC_
00017
00018 // $Id: TypeManip.h 749 2006-10-17 19:49:26Z syntheticpp $
00019
00020
00021 namespace Loki
00022 {
00024 // class template Int2Type
00025 // Converts each integral constant into a unique type
00026 // Invocation: Int2Type<v> where v is a compile-time constant integral
00027 // Defines 'value', an enum that evaluates to v
00029
00030     template <int v>
00031     struct Int2Type
00032     {
00033         enum { value = v };
00034     };
00035
00037 // class template Type2Type
00038 // Converts each type into a unique, insipid type
00039 // Invocation Type2Type<T> where T is a type
00040 // Defines the type OriginalType which maps back to T
00042
00043     template <typename T>
00044     struct Type2Type
00045     {
00046         typedef T OriginalType;
00047     };
00048
00050 // class template Select
00051 // Selects one of two types based upon a boolean constant
00052 // Invocation: Select<flag, T, U>::Result
00053 // where:
00054 // flag is a compile-time boolean constant
00055 // T and U are types
00056 // Result evaluates to T if flag is true, and to U otherwise.
00058
00059     template <bool flag, typename T, typename U>
00060     struct Select
00061     {
00062         typedef T Result;
00063     };
00064     template <typename T, typename U>
00065     struct Select<false, T, U>
00066     {
00067         typedef U Result;
00068     };
00069
00071 // class template IsSameType
00072 // Return true iff two given types are the same
00073 // Invocation: SameType<T, U>::value
00074 // where:
00075 // T and U are types
00076 // Result evaluates to true iff U == T (types equal)
00078
00079     template <typename T, typename U>
00080     struct IsSameType
00081     {
00082         enum { value = false };
00083     };
00084
00085     template <typename T>
00086     struct IsSameType<T,T>
00087     {
00088         enum { value = true };
00089     };
00090
00092 // Helper types Small and Big - guarantee that sizeof(Small) < sizeof(Big)
00094
00095     namespace Private
00096     {
00097         template <class T, class U>
00098         struct ConversionHelper
00099         {
00100             typedef char Small;
00101             struct Big { char dummy[2]; };
00102             static Big   Test(...);
00103             static Small Test(U);
00104             static T MakeT();
00105         };
00106     }
00107
00109 // class template Conversion
00110 // Figures out the conversion relationships between two types
00111 // Invocations (T and U are types):
00112 // a) Conversion<T, U>::exists
00113 // returns (at compile time) true if there is an implicit conversion from T
00114 // to U (example: Derived to Base)
00115 // b) Conversion<T, U>::exists2Way
00116 // returns (at compile time) true if there are both conversions from T
00117 // to U and from U to T (example: int to char and back)
00118 // c) Conversion<T, U>::sameType
00119 // returns (at compile time) true if T and U represent the same type
00120 //
00121 // Caveat: might not work if T and U are in a private inheritance hierarchy.
00123
00124     template <class T, class U>
00125     struct Conversion
00126     {
00127         typedef Private::ConversionHelper<T, U> H;
00128 #ifndef __MWERKS__
00129         enum { exists = sizeof(typename H::Small) == sizeof((H::Test(H::MakeT()))) };
00130 #else
00131         enum { exists = false };
00132 #endif
00133         enum { exists2Way = exists && Conversion<U, T>::exists };
00134         enum { sameType = false };
00135     };
00136
00137     template <class T>
00138     struct Conversion<T, T>
00139     {
00140         enum { exists = 1, exists2Way = 1, sameType = 1 };
00141     };
00142
00143     template <class T>
00144     struct Conversion<void, T>
00145     {
00146         enum { exists = 0, exists2Way = 0, sameType = 0 };
00147     };
00148
00149     template <class T>
00150     struct Conversion<T, void>
00151     {
00152         enum { exists = 0, exists2Way = 0, sameType = 0 };
00153     };
00154
00155     template <>
00156     struct Conversion<void, void>
00157     {
00158     public:
00159         enum { exists = 1, exists2Way = 1, sameType = 1 };
00160     };
00161
00163 // class template SuperSubclass
00164 // Invocation: SuperSubclass<B, D>::value where B and D are types.
00165 // Returns true if B is a public base of D, or if B and D are aliases of the
00166 // same type.
00167 //
00168 // Caveat: might not work if T and U are in a private inheritance hierarchy.
00170
00171 template <class T, class U>
00172 struct SuperSubclass
00173 {
00174     enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists &&
00175                   !::Loki::Conversion<const volatile T*, const volatile void*>::sameType) };
00176
00177     // Dummy enum to make sure that both classes are fully defined.
00178     enum{ dontUseWithIncompleteTypes = ( sizeof (T) == sizeof (U) ) };
00179 };
00180
00181 template <>
00182 struct SuperSubclass<void, void>
00183 {
00184     enum { value = false };
00185 };
00186
00187 template <class U>
00188 struct SuperSubclass<void, U>
00189 {
00190     enum { value = (::Loki::Conversion<const volatile U*, const volatile void*>::exists &&
00191                   !::Loki::Conversion<const volatile void*, const volatile void*>::sameType) };
00192
00193     // Dummy enum to make sure that both classes are fully defined.
00194     enum{ dontUseWithIncompleteTypes = ( 0 == sizeof (U) ) };
00195 };
00196
00197 template <class T>
00198 struct SuperSubclass<T, void>
00199 {
00200     enum { value = (::Loki::Conversion<const volatile void*, const volatile T*>::exists &&
00201                   !::Loki::Conversion<const volatile T*, const volatile void*>::sameType) };
00202
00203     // Dummy enum to make sure that both classes are fully defined.
00204     enum{ dontUseWithIncompleteTypes = ( sizeof (T) == 0 ) };
00205 };
00206
00208 // class template SuperSubclassStrict
00209 // Invocation: SuperSubclassStrict<B, D>::value where B and D are types.
00210 // Returns true if B is a public base of D.
00211 //
00212 // Caveat: might not work if T and U are in a private inheritance hierarchy.
00214
00215 template<class T,class U>
00216 struct SuperSubclassStrict
00217 {
00218     enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists &&
00219                  !::Loki::Conversion<const volatile T*, const volatile void*>::sameType &&
00220                  !::Loki::Conversion<const volatile T*, const volatile U*>::sameType) };
00221
00222     // Dummy enum to make sure that both classes are fully defined.
00223     enum{ dontUseWithIncompleteTypes = ( sizeof (T) == sizeof (U) ) };
00224 };
00225
00226 template<>
00227 struct SuperSubclassStrict<void, void>
00228 {
00229     enum { value = false };
00230 };
00231
00232 template<class U>
00233 struct SuperSubclassStrict<void, U>
00234 {
00235     enum { value = (::Loki::Conversion<const volatile U*, const volatile void*>::exists &&
00236                  !::Loki::Conversion<const volatile void*, const volatile void*>::sameType &&
00237                  !::Loki::Conversion<const volatile void*, const volatile U*>::sameType) };
00238
00239     // Dummy enum to make sure that both classes are fully defined.
00240     enum{ dontUseWithIncompleteTypes = ( 0 == sizeof (U) ) };
00241 };
00242
00243 template<class T>
00244 struct SuperSubclassStrict<T, void>
00245 {
00246     enum { value = (::Loki::Conversion<const volatile void*, const volatile T*>::exists &&
00247                  !::Loki::Conversion<const volatile T*, const volatile void*>::sameType &&
00248                  !::Loki::Conversion<const volatile T*, const volatile void*>::sameType) };
00249
00250     // Dummy enum to make sure that both classes are fully defined.
00251     enum{ dontUseWithIncompleteTypes = ( sizeof (T) == 0 ) };
00252 };
00253
00254
00255 }   // namespace Loki
00256
00258 // macro SUPERSUBCLASS
00259 // Invocation: SUPERSUBCLASS(B, D) where B and D are types.
00260 // Returns true if B is a public base of D, or if B and D are aliases of the
00261 // same type.
00262 //
00263 // Caveat: might not work if T and U are in a private inheritance hierarchy.
00264 // Deprecated: Use SuperSubclass class template instead.
00266
00267 #define LOKI_SUPERSUBCLASS(T, U) \
00268     ::Loki::SuperSubclass<T,U>::value
00269
00271 // macro SUPERSUBCLASS_STRICT
00272 // Invocation: SUPERSUBCLASS(B, D) where B and D are types.
00273 // Returns true if B is a public base of D.
00274 //
00275 // Caveat: might not work if T and U are in a private inheritance hierarchy.
00276 // Deprecated: Use SuperSubclassStrict class template instead.
00278
00279 #define LOKI_SUPERSUBCLASS_STRICT(T, U) \
00280     ::Loki::SuperSubclassStrict<T,U>::value
00281
00282
00283 #endif // end file guardian
00284
Generated on Sat Jul 7 15:11:04 2007 for Loki by doxygen 1.5.1-p1


Loki: TypeTraits.h Source File

TypeTraits.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_TYPETRAITS_INC_
00016 #define LOKI_TYPETRAITS_INC_
00017
00018 // $Id: TypeTraits.h 749 2006-10-17 19:49:26Z syntheticpp $
00019
00020
00021 #include "Typelist.h"
00022 #include "Sequence.h"
00023
00024 #if (defined _MSC_VER) && (_MSC_VER < 1400)
00025 #include <string>
00026 #endif
00027
00028
00029 #ifdef _MSC_VER
00030 #pragma warning( push )
00031 #pragma warning( disable : 4180 ) //qualifier applied to function type has no meaning; ignored
00032 #endif
00033
00034 namespace Loki
00035 {
00037 // class template IsCustomUnsignedInt
00038 // Offers a means to integrate nonstandard built-in unsigned integral types
00039 // (such as unsigned __int64 or unsigned long long int) with the TypeTraits
00040 //     class template defined below.
00041 // Invocation: IsCustomUnsignedInt<T> where T is any type
00042 // Defines 'value', an enum that is 1 iff T is a custom built-in unsigned
00043 //     integral type
00044 // Specialize this class template for nonstandard unsigned integral types
00045 //     and define value = 1 in those specializations
00047
00048     template <typename T>
00049     struct IsCustomUnsignedInt
00050     {
00051         enum { value = 0 };
00052     };
00053
00055 // class template IsCustomSignedInt
00056 // Offers a means to integrate nonstandard built-in unsigned integral types
00057 // (such as unsigned __int64 or unsigned long long int) with the TypeTraits
00058 //     class template defined below.
00059 // Invocation: IsCustomSignedInt<T> where T is any type
00060 // Defines 'value', an enum that is 1 iff T is a custom built-in signed
00061 //     integral type
00062 // Specialize this class template for nonstandard unsigned integral types
00063 //     and define value = 1 in those specializations
00065
00066     template <typename T>
00067     struct IsCustomSignedInt
00068     {
00069         enum { value = 0 };
00070     };
00071
00073 // class template IsCustomFloat
00074 // Offers a means to integrate nonstandard floating point types with the
00075 //     TypeTraits class template defined below.
00076 // Invocation: IsCustomFloat<T> where T is any type
00077 // Defines 'value', an enum that is 1 iff T is a custom built-in
00078 //     floating point type
00079 // Specialize this class template for nonstandard unsigned integral types
00080 //     and define value = 1 in those specializations
00082
00083     template <typename T>
00084     struct IsCustomFloat
00085     {
00086         enum { value = 0 };
00087     };
00088
00090 // Helper types for class template TypeTraits defined below
00092
00093     namespace Private
00094     {
00095 #ifndef LOKI_DISABLE_TYPELIST_MACROS
00096         typedef LOKI_TYPELIST_4(unsigned char, unsigned short int,unsigned int, unsigned long int)
00097             StdUnsignedInts;
00098         typedef LOKI_TYPELIST_4(signed char, short int,int, long int)
00099             StdSignedInts;
00100         typedef LOKI_TYPELIST_3(bool, char, wchar_t)
00101             StdOtherInts;
00102         typedef LOKI_TYPELIST_3(float, double, long double)
00103             StdFloats;
00104 #else
00105         typedef Loki::Seq<unsigned char, unsigned short int,unsigned int, unsigned long int>::Type
00106             StdUnsignedInts;
00107         typedef Loki::Seq<signed char, short int,int, long int>::Type
00108             StdSignedInts;
00109         typedef Loki::Seq<bool, char, wchar_t>::Type
00110             StdOtherInts;
00111         typedef Loki::Seq<float, double, long double>::Type
00112             StdFloats;
00113
00114 #endif
00115         template <typename U> struct AddPointer
00116         {
00117             typedef U* Result;
00118         };
00119
00120         template <typename U> struct AddPointer<U&>
00121         {
00122             typedef U* Result;
00123         };
00124
00125         template <class U> struct AddReference
00126         {
00127             typedef U & Result;
00128         };
00129
00130         template <class U> struct AddReference<U &>
00131         {
00132             typedef U & Result;
00133         };
00134
00135         template <> struct AddReference<void>
00136         {
00137             typedef NullType Result;
00138         };
00139
00140         template <class U> struct AddParameterType
00141         {
00142             typedef const U & Result;
00143         };
00144
00145         template <class U> struct AddParameterType<U &>
00146         {
00147             typedef U & Result;
00148         };
00149
00150         template <> struct AddParameterType<void>
00151         {
00152             typedef NullType Result;
00153         };
00154
00155         template <typename T>
00156         struct IsFunctionPointerRaw
00157         {enum{result = 0};};
00158
00159         template <typename T>
00160         struct IsFunctionPointerRaw<T(*)()>
00161         {enum {result = 1};};
00162
00163         template <typename T,
00164             typename P01>
00165         struct IsFunctionPointerRaw<T(*)(P01)>
00166         {enum {result = 1};};
00167
00168         template <typename T,
00169             typename P01, typename P02>
00170         struct IsFunctionPointerRaw<T(*)(
00171             P01, P02)>
00172         {enum {result = 1};};
00173
00174         template <typename T,
00175             typename P01, typename P02, typename P03>
00176         struct IsFunctionPointerRaw<T(*)(
00177             P01, P02, P03)>
00178         {enum {result = 1};};
00179
00180         template <typename T,
00181             typename P01, typename P02, typename P03, typename P04>
00182         struct IsFunctionPointerRaw<T(*)(
00183             P01, P02, P03, P04)>
00184         {enum {result = 1};};
00185
00186         template <typename T,
00187             typename P01, typename P02, typename P03, typename P04, typename P05>
00188         struct IsFunctionPointerRaw<T(*)(
00189             P01, P02, P03, P04, P05)>
00190         {enum {result = 1};};
00191
00192         template <typename T,
00193             typename P01, typename P02, typename P03, typename P04, typename P05,
00194             typename P06>
00195         struct IsFunctionPointerRaw<T(*)(
00196             P01, P02, P03, P04, P05,
00197             P06)>
00198         {enum {result = 1};};
00199
00200         template <typename T,
00201             typename P01, typename P02, typename P03, typename P04, typename P05,
00202             typename P06, typename P07>
00203         struct IsFunctionPointerRaw<T(*)(
00204             P01, P02, P03, P04, P05,
00205             P06, P07)>
00206         {enum {result = 1};};
00207
00208         template <typename T,
00209             typename P01, typename P02, typename P03, typename P04, typename P05,
00210             typename P06, typename P07, typename P08>
00211         struct IsFunctionPointerRaw<T(*)(
00212             P01, P02, P03, P04, P05,
00213             P06, P07, P08)>
00214         {enum {result = 1};};
00215
00216         template <typename T,
00217             typename P01, typename P02, typename P03, typename P04, typename P05,
00218             typename P06, typename P07, typename P08, typename P09>
00219         struct IsFunctionPointerRaw<T(*)(
00220             P01, P02, P03, P04, P05,
00221             P06, P07, P08, P09)>
00222         {enum {result = 1};};
00223
00224         template <typename T,
00225             typename P01, typename P02, typename P03, typename P04, typename P05,
00226             typename P06, typename P07, typename P08, typename P09, typename P10>
00227         struct IsFunctionPointerRaw<T(*)(
00228             P01, P02, P03, P04, P05,
00229             P06, P07, P08, P09, P10)>
00230         {enum {result = 1};};
00231
00232         template <typename T,
00233             typename P01, typename P02, typename P03, typename P04, typename P05,
00234             typename P06, typename P07, typename P08, typename P09, typename P10,
00235             typename P11>
00236         struct IsFunctionPointerRaw<T(*)(
00237             P01, P02, P03, P04, P05,
00238             P06, P07, P08, P09, P10,
00239             P11)>
00240         {enum {result = 1};};
00241
00242         template <typename T,
00243             typename P01, typename P02, typename P03, typename P04, typename P05,
00244             typename P06, typename P07, typename P08, typename P09, typename P10,
00245             typename P11, typename P12>
00246         struct IsFunctionPointerRaw<T(*)(
00247             P01, P02, P03, P04, P05,
00248             P06, P07, P08, P09, P10,
00249             P11, P12)>
00250         {enum {result = 1};};
00251
00252         template <typename T,
00253             typename P01, typename P02, typename P03, typename P04, typename P05,
00254             typename P06, typename P07, typename P08, typename P09, typename P10,
00255             typename P11, typename P12, typename P13>
00256         struct IsFunctionPointerRaw<T(*)(
00257             P01, P02, P03, P04, P05,
00258             P06, P07, P08, P09, P10,
00259             P11, P12, P13)>
00260         {enum {result = 1};};
00261
00262         template <typename T,
00263             typename P01, typename P02, typename P03, typename P04, typename P05,
00264             typename P06, typename P07, typename P08, typename P09, typename P10,
00265             typename P11, typename P12, typename P13, typename P14>
00266         struct IsFunctionPointerRaw<T(*)(
00267             P01, P02, P03, P04, P05,
00268             P06, P07, P08, P09, P10,
00269             P11, P12, P13, P14)>
00270         {enum {result = 1};};
00271
00272         template <typename T,
00273             typename P01, typename P02, typename P03, typename P04, typename P05,
00274             typename P06, typename P07, typename P08, typename P09, typename P10,
00275             typename P11, typename P12, typename P13, typename P14, typename P15>
00276         struct IsFunctionPointerRaw<T(*)(
00277             P01, P02, P03, P04, P05,
00278             P06, P07, P08, P09, P10,
00279             P11, P12, P13, P14, P15)>
00280         {enum {result = 1};};
00281
00282         template <typename T,
00283             typename P01, typename P02, typename P03, typename P04, typename P05,
00284             typename P06, typename P07, typename P08, typename P09, typename P10,
00285             typename P11, typename P12, typename P13, typename P14, typename P15,
00286             typename P16>
00287         struct IsFunctionPointerRaw<T(*)(
00288             P01, P02, P03, P04, P05,
00289             P06, P07, P08, P09, P10,
00290             P11, P12, P13, P14, P15,
00291             P16)>
00292         {enum {result = 1};};
00293
00294         template <typename T,
00295             typename P01, typename P02, typename P03, typename P04, typename P05,
00296             typename P06, typename P07, typename P08, typename P09, typename P10,
00297             typename P11, typename P12, typename P13, typename P14, typename P15,
00298             typename P16, typename P17>
00299         struct IsFunctionPointerRaw<T(*)(
00300             P01, P02, P03, P04, P05,
00301             P06, P07, P08, P09, P10,
00302             P11, P12, P13, P14, P15,
00303             P16, P17)>
00304         {enum {result = 1};};
00305
00306         template <typename T,
00307             typename P01, typename P02, typename P03, typename P04, typename P05,
00308             typename P06, typename P07, typename P08, typename P09, typename P10,
00309             typename P11, typename P12, typename P13, typename P14, typename P15,
00310             typename P16, typename P17, typename P18>
00311         struct IsFunctionPointerRaw<T(*)(
00312             P01, P02, P03, P04, P05,
00313             P06, P07, P08, P09, P10,
00314             P11, P12, P13, P14, P15,
00315             P16, P17, P18)>
00316         {enum {result = 1};};
00317
00318         template <typename T,
00319             typename P01, typename P02, typename P03, typename P04, typename P05,
00320             typename P06, typename P07, typename P08, typename P09, typename P10,
00321             typename P11, typename P12, typename P13, typename P14, typename P15,
00322             typename P16, typename P17, typename P18, typename P19>
00323         struct IsFunctionPointerRaw<T(*)(
00324             P01, P02, P03, P04, P05,
00325             P06, P07, P08, P09, P10,
00326             P11, P12, P13, P14, P15,
00327             P16, P17, P18, P19)>
00328         {enum {result = 1};};
00329
00330         template <typename T,
00331             typename P01, typename P02, typename P03, typename P04, typename P05,
00332             typename P06, typename P07, typename P08, typename P09, typename P10,
00333             typename P11, typename P12, typename P13, typename P14, typename P15,
00334             typename P16, typename P17, typename P18, typename P19, typename P20>
00335         struct IsFunctionPointerRaw<T(*)(
00336             P01, P02, P03, P04, P05,
00337             P06, P07, P08, P09, P10,
00338             P11, P12, P13, P14, P15,
00339             P16, P17, P18, P19, P20)>
00340         {enum {result = 1};};
00341
00342         template <typename T>
00343         struct IsFunctionPointerRaw<T(*)(
00344             ...)>
00345         {enum {result = 1};};
00346
00347         template <typename T,
00348             typename P01>
00349         struct IsFunctionPointerRaw<T(*)(
00350             P01, ...)>
00351         {enum {result = 1};};
00352
00353         template <typename T,
00354             typename P01, typename P02>
00355         struct IsFunctionPointerRaw<T(*)(
00356             P01, P02, ...)>
00357         {enum {result = 1};};
00358
00359         template <typename T,
00360             typename P01, typename P02, typename P03>
00361         struct IsFunctionPointerRaw<T(*)(
00362             P01, P02, P03, ...)>
00363         {enum {result = 1};};
00364
00365         template <typename T,
00366             typename P01, typename P02, typename P03, typename P04>
00367         struct IsFunctionPointerRaw<T(*)(
00368             P01, P02, P03, P04, ...)>
00369         {enum {result = 1};};
00370
00371         template <typename T,
00372             typename P01, typename P02, typename P03, typename P04, typename P05>
00373         struct IsFunctionPointerRaw<T(*)(
00374             P01, P02, P03, P04, P05,
00375             ...)>
00376         {enum {result = 1};};
00377
00378         template <typename T,
00379             typename P01, typename P02, typename P03, typename P04, typename P05,
00380             typename P06>
00381         struct IsFunctionPointerRaw<T(*)(
00382             P01, P02, P03, P04, P05,
00383             P06, ...)>
00384         {enum {result = 1};};
00385
00386         template <typename T,
00387             typename P01, typename P02, typename P03, typename P04, typename P05,
00388             typename P06, typename P07>
00389         struct IsFunctionPointerRaw<T(*)(
00390             P01, P02, P03, P04, P05,
00391             P06, P07, ...)>
00392         {enum {result = 1};};
00393
00394         template <typename T,
00395             typename P01, typename P02, typename P03, typename P04, typename P05,
00396             typename P06, typename P07, typename P08>
00397         struct IsFunctionPointerRaw<T(*)(
00398             P01, P02, P03, P04, P05,
00399             P06, P07, P08, ...)>
00400         {enum {result = 1};};
00401
00402         template <typename T,
00403             typename P01, typename P02, typename P03, typename P04, typename P05,
00404             typename P06, typename P07, typename P08, typename P09>
00405         struct IsFunctionPointerRaw<T(*)(
00406             P01, P02, P03, P04, P05,
00407             P06, P07, P08, P09, ...)>
00408         {enum {result = 1};};
00409
00410         template <typename T,
00411             typename P01, typename P02, typename P03, typename P04, typename P05,
00412             typename P06, typename P07, typename P08, typename P09, typename P10>
00413         struct IsFunctionPointerRaw<T(*)(
00414             P01, P02, P03, P04, P05,
00415             P06, P07, P08, P09, P10,
00416             ...)>
00417         {enum {result = 1};};
00418
00419         template <typename T,
00420             typename P01, typename P02, typename P03, typename P04, typename P05,
00421             typename P06, typename P07, typename P08, typename P09, typename P10,
00422             typename P11>
00423         struct IsFunctionPointerRaw<T(*)(
00424             P01, P02, P03, P04, P05,
00425             P06, P07, P08, P09, P10,
00426             P11, ...)>
00427         {enum {result = 1};};
00428
00429         template <typename T,
00430             typename P01, typename P02, typename P03, typename P04, typename P05,
00431             typename P06, typename P07, typename P08, typename P09, typename P10,
00432             typename P11, typename P12>
00433         struct IsFunctionPointerRaw<T(*)(
00434             P01, P02, P03, P04, P05,
00435             P06, P07, P08, P09, P10,
00436             P11, P12, ...)>
00437         {enum {result = 1};};
00438
00439         template <typename T,
00440             typename P01, typename P02, typename P03, typename P04, typename P05,
00441             typename P06, typename P07, typename P08, typename P09, typename P10,
00442             typename P11, typename P12, typename P13>
00443         struct IsFunctionPointerRaw<T(*)(
00444             P01, P02, P03, P04, P05,
00445             P06, P07, P08, P09, P10,
00446             P11, P12, P13, ...)>
00447         {enum {result = 1};};
00448
00449         template <typename T,
00450             typename P01, typename P02, typename P03, typename P04, typename P05,
00451             typename P06, typename P07, typename P08, typename P09, typename P10,
00452             typename P11, typename P12, typename P13, typename P14>
00453         struct IsFunctionPointerRaw<T(*)(
00454             P01, P02, P03, P04, P05,
00455             P06, P07, P08, P09, P10,
00456             P11, P12, P13, P14, ...)>
00457         {enum {result = 1};};
00458
00459         template <typename T,
00460             typename P01, typename P02, typename P03, typename P04, typename P05,
00461             typename P06, typename P07, typename P08, typename P09, typename P10,
00462             typename P11, typename P12, typename P13, typename P14, typename P15>
00463         struct IsFunctionPointerRaw<T(*)(
00464             P01, P02, P03, P04, P05,
00465             P06, P07, P08, P09, P10,
00466             P11, P12, P13, P14, P15,
00467             ...)>
00468         {enum {result = 1};};
00469
00470         template <typename T,
00471             typename P01, typename P02, typename P03, typename P04, typename P05,
00472             typename P06, typename P07, typename P08, typename P09, typename P10,
00473             typename P11, typename P12, typename P13, typename P14, typename P15,
00474             typename P16>
00475         struct IsFunctionPointerRaw<T(*)(
00476             P01, P02, P03, P04, P05,
00477             P06, P07, P08, P09, P10,
00478             P11, P12, P13, P14, P15,
00479             P16, ...)>
00480         {enum {result = 1};};
00481
00482         template <typename T,
00483             typename P01, typename P02, typename P03, typename P04, typename P05,
00484             typename P06, typename P07, typename P08, typename P09, typename P10,
00485             typename P11, typename P12, typename P13, typename P14, typename P15,
00486             typename P16, typename P17>
00487         struct IsFunctionPointerRaw<T(*)(
00488             P01, P02, P03, P04, P05,
00489             P06, P07, P08, P09, P10,
00490             P11, P12, P13, P14, P15,
00491             P16, P17, ...)>
00492         {enum {result = 1};};
00493
00494         template <typename T,
00495             typename P01, typename P02, typename P03, typename P04, typename P05,
00496             typename P06, typename P07, typename P08, typename P09, typename P10,
00497             typename P11, typename P12, typename P13, typename P14, typename P15,
00498             typename P16, typename P17, typename P18>
00499         struct IsFunctionPointerRaw<T(*)(
00500             P01, P02, P03, P04, P05,
00501             P06, P07, P08, P09, P10,
00502             P11, P12, P13, P14, P15,
00503             P16, P17, P18, ...)>
00504         {enum {result = 1};};
00505
00506         template <typename T,
00507             typename P01, typename P02, typename P03, typename P04, typename P05,
00508             typename P06, typename P07, typename P08, typename P09, typename P10,
00509             typename P11, typename P12, typename P13, typename P14, typename P15,
00510             typename P16, typename P17, typename P18, typename P19>
00511         struct IsFunctionPointerRaw<T(*)(
00512             P01, P02, P03, P04, P05,
00513             P06, P07, P08, P09, P10,
00514             P11, P12, P13, P14, P15,
00515             P16, P17, P18, P19, ...)>
00516         {enum {result = 1};};
00517
00518         template <typename T,
00519             typename P01, typename P02, typename P03, typename P04, typename P05,
00520             typename P06, typename P07, typename P08, typename P09, typename P10,
00521             typename P11, typename P12, typename P13, typename P14, typename P15,
00522             typename P16, typename P17, typename P18, typename P19, typename P20>
00523         struct IsFunctionPointerRaw<T(*)(
00524             P01, P02, P03, P04, P05,
00525             P06, P07, P08, P09, P10,
00526             P11, P12, P13, P14, P15,
00527             P16, P17, P18, P19, P20,
00528             ...)>
00529         {enum {result = 1};};
00530
00531
00532         template <typename T>
00533         struct IsMemberFunctionPointerRaw
00534         {enum{result = 0};};
00535
00536         template <typename T, typename S>
00537         struct IsMemberFunctionPointerRaw<T (S::*)()>
00538         {enum {result = 1};};
00539
00540         template <typename T, typename S,
00541             typename P01>
00542         struct IsMemberFunctionPointerRaw<T (S::*)(P01)>
00543         {enum {result = 1};};
00544
00545         template <typename T, typename S,
00546             typename P01, typename P02>
00547         struct IsMemberFunctionPointerRaw<T (S::*)(
00548             P01, P02)>
00549         {enum {result = 1};};
00550
00551         template <typename T, typename S,
00552             typename P01, typename P02, typename P03>
00553         struct IsMemberFunctionPointerRaw<T (S::*)(
00554             P01, P02, P03)>
00555         {enum {result = 1};};
00556
00557         template <typename T, typename S,
00558             typename P01, typename P02, typename P03, typename P04>
00559         struct IsMemberFunctionPointerRaw<T (S::*)(
00560             P01, P02, P03, P04)>
00561         {enum {result = 1};};
00562
00563         template <typename T, typename S,
00564             typename P01, typename P02, typename P03, typename P04, typename P05>
00565         struct IsMemberFunctionPointerRaw<T (S::*)(
00566             P01, P02, P03, P04, P05)>
00567         {enum {result = 1};};
00568
00569         template <typename T, typename S,
00570             typename P01, typename P02, typename P03, typename P04, typename P05,
00571             typename P06>
00572         struct IsMemberFunctionPointerRaw<T (S::*)(
00573             P01, P02, P03, P04, P05,
00574             P06)>
00575         {enum {result = 1};};
00576
00577         template <typename T, typename S,
00578             typename P01, typename P02, typename P03, typename P04, typename P05,
00579             typename P06, typename P07>
00580         struct IsMemberFunctionPointerRaw<T (S::*)(
00581             P01, P02, P03, P04, P05,
00582             P06, P07)>
00583         {enum {result = 1};};
00584
00585         template <typename T, typename S,
00586             typename P01, typename P02, typename P03, typename P04, typename P05,
00587             typename P06, typename P07, typename P08>
00588         struct IsMemberFunctionPointerRaw<T (S::*)(
00589             P01, P02, P03, P04, P05,
00590             P06, P07, P08)>
00591         {enum {result = 1};};
00592
00593         template <typename T, typename S,
00594             typename P01, typename P02, typename P03, typename P04, typename P05,
00595             typename P06, typename P07, typename P08, typename P09>
00596         struct IsMemberFunctionPointerRaw<T (S::*)(
00597             P01, P02, P03, P04, P05,
00598             P06, P07, P08, P09)>
00599         {enum {result = 1};};
00600
00601         template <typename T, typename S,
00602             typename P01, typename P02, typename P03, typename P04, typename P05,
00603             typename P06, typename P07, typename P08, typename P09, typename P10>
00604         struct IsMemberFunctionPointerRaw<T (S::*)(
00605             P01, P02, P03, P04, P05,
00606             P06, P07, P08, P09, P10)>
00607         {enum {result = 1};};
00608
00609         template <typename T, typename S,
00610             typename P01, typename P02, typename P03, typename P04, typename P05,
00611             typename P06, typename P07, typename P08, typename P09, typename P10,
00612             typename P11>
00613         struct IsMemberFunctionPointerRaw<T (S::*)(
00614             P01, P02, P03, P04, P05,
00615             P06, P07, P08, P09, P10,
00616             P11)>
00617         {enum {result = 1};};
00618
00619         template <typename T, typename S,
00620             typename P01, typename P02, typename P03, typename P04, typename P05,
00621             typename P06, typename P07, typename P08, typename P09, typename P10,
00622             typename P11, typename P12>
00623         struct IsMemberFunctionPointerRaw<T (S::*)(
00624             P01, P02, P03, P04, P05,
00625             P06, P07, P08, P09, P10,
00626             P11, P12)>
00627         {enum {result = 1};};
00628
00629         template <typename T, typename S,
00630             typename P01, typename P02, typename P03, typename P04, typename P05,
00631             typename P06, typename P07, typename P08, typename P09, typename P10,
00632             typename P11, typename P12, typename P13>
00633         struct IsMemberFunctionPointerRaw<T (S::*)(
00634             P01, P02, P03, P04, P05,
00635             P06, P07, P08, P09, P10,
00636             P11, P12, P13)>
00637         {enum {result = 1};};
00638
00639         template <typename T, typename S,
00640             typename P01, typename P02, typename P03, typename P04, typename P05,
00641             typename P06, typename P07, typename P08, typename P09, typename P10,
00642             typename P11, typename P12, typename P13, typename P14>
00643         struct IsMemberFunctionPointerRaw<T (S::*)(
00644             P01, P02, P03, P04, P05,
00645             P06, P07, P08, P09, P10,
00646             P11, P12, P13, P14)>
00647         {enum {result = 1};};
00648
00649         template <typename T, typename S,
00650             typename P01, typename P02, typename P03, typename P04, typename P05,
00651             typename P06, typename P07, typename P08, typename P09, typename P10,
00652             typename P11, typename P12, typename P13, typename P14, typename P15>
00653         struct IsMemberFunctionPointerRaw<T (S::*)(
00654             P01, P02, P03, P04, P05,
00655             P06, P07, P08, P09, P10,
00656             P11, P12, P13, P14, P15)>
00657         {enum {result = 1};};
00658
00659         template <typename T, typename S,
00660             typename P01, typename P02, typename P03, typename P04, typename P05,
00661             typename P06, typename P07, typename P08, typename P09, typename P10,
00662             typename P11, typename P12, typename P13, typename P14, typename P15,
00663             typename P16>
00664         struct IsMemberFunctionPointerRaw<T (S::*)(
00665             P01, P02, P03, P04, P05,
00666             P06, P07, P08, P09, P10,
00667             P11, P12, P13, P14, P15,
00668             P16)>
00669         {enum {result = 1};};
00670
00671         template <typename T, typename S,
00672             typename P01, typename P02, typename P03, typename P04, typename P05,
00673             typename P06, typename P07, typename P08, typename P09, typename P10,
00674             typename P11, typename P12, typename P13, typename P14, typename P15,
00675             typename P16, typename P17>
00676         struct IsMemberFunctionPointerRaw<T (S::*)(
00677             P01, P02, P03, P04, P05,
00678             P06, P07, P08, P09, P10,
00679             P11, P12, P13, P14, P15,
00680             P16, P17)>
00681         {enum {result = 1};};
00682
00683         template <typename T, typename S,
00684             typename P01, typename P02, typename P03, typename P04, typename P05,
00685             typename P06, typename P07, typename P08, typename P09, typename P10,
00686             typename P11, typename P12, typename P13, typename P14, typename P15,
00687             typename P16, typename P17, typename P18>
00688         struct IsMemberFunctionPointerRaw<T (S::*)(
00689             P01, P02, P03, P04, P05,
00690             P06, P07, P08, P09, P10,
00691             P11, P12, P13, P14, P15,
00692             P16, P17, P18)>
00693         {enum {result = 1};};
00694
00695         template <typename T, typename S,
00696             typename P01, typename P02, typename P03, typename P04, typename P05,
00697             typename P06, typename P07, typename P08, typename P09, typename P10,
00698             typename P11, typename P12, typename P13, typename P14, typename P15,
00699             typename P16, typename P17, typename P18, typename P19>
00700         struct IsMemberFunctionPointerRaw<T (S::*)(
00701             P01, P02, P03, P04, P05,
00702             P06, P07, P08, P09, P10,
00703             P11, P12, P13, P14, P15,
00704             P16, P17, P18, P19)>
00705         {enum {result = 1};};
00706
00707         template <typename T, typename S,
00708             typename P01, typename P02, typename P03, typename P04, typename P05,
00709             typename P06, typename P07, typename P08, typename P09, typename P10,
00710             typename P11, typename P12, typename P13, typename P14, typename P15,
00711             typename P16, typename P17, typename P18, typename P19, typename P20>
00712         struct IsMemberFunctionPointerRaw<T (S::*)(
00713             P01, P02, P03, P04, P05,
00714             P06, P07, P08, P09, P10,
00715             P11, P12, P13, P14, P15,
00716             P16, P17, P18, P19, P20)>
00717         {enum {result = 1};};
00718
00719         template <typename T, typename S>
00720         struct IsMemberFunctionPointerRaw<T (S::*)(
00721             ...)>
00722         {enum {result = 1};};
00723
00724         template <typename T, typename S,
00725             typename P01>
00726         struct IsMemberFunctionPointerRaw<T (S::*)(
00727             P01, ...)>
00728         {enum {result = 1};};
00729
00730         template <typename T, typename S,
00731             typename P01, typename P02>
00732         struct IsMemberFunctionPointerRaw<T (S::*)(
00733             P01, P02, ...)>
00734         {enum {result = 1};};
00735
00736         template <typename T, typename S,
00737             typename P01, typename P02, typename P03>
00738         struct IsMemberFunctionPointerRaw<T (S::*)(
00739             P01, P02, P03, ...)>
00740         {enum {result = 1};};
00741
00742         template <typename T, typename S,
00743             typename P01, typename P02, typename P03, typename P04>
00744         struct IsMemberFunctionPointerRaw<T (S::*)(
00745             P01, P02, P03, P04, ...)>
00746         {enum {result = 1};};
00747
00748         template <typename T, typename S,
00749             typename P01, typename P02, typename P03, typename P04, typename P05>
00750         struct IsMemberFunctionPointerRaw<T (S::*)(
00751             P01, P02, P03, P04, P05,
00752             ...)>
00753         {enum {result = 1};};
00754
00755         template <typename T, typename S,
00756             typename P01, typename P02, typename P03, typename P04, typename P05,
00757             typename P06>
00758         struct IsMemberFunctionPointerRaw<T (S::*)(
00759             P01, P02, P03, P04, P05,
00760             P06, ...)>
00761         {enum {result = 1};};
00762
00763         template <typename T, typename S,
00764             typename P01, typename P02, typename P03, typename P04, typename P05,
00765             typename P06, typename P07>
00766         struct IsMemberFunctionPointerRaw<T (S::*)(
00767             P01, P02, P03, P04, P05,
00768             P06, P07, ...)>
00769         {enum {result = 1};};
00770
00771         template <typename T, typename S,
00772             typename P01, typename P02, typename P03, typename P04, typename P05,
00773             typename P06, typename P07, typename P08>
00774         struct IsMemberFunctionPointerRaw<T (S::*)(
00775             P01, P02, P03, P04, P05,
00776             P06, P07, P08, ...)>
00777         {enum {result = 1};};
00778
00779         template <typename T, typename S,
00780             typename P01, typename P02, typename P03, typename P04, typename P05,
00781             typename P06, typename P07, typename P08, typename P09>
00782         struct IsMemberFunctionPointerRaw<T (S::*)(
00783             P01, P02, P03, P04, P05,
00784             P06, P07, P08, P09, ...)>
00785         {enum {result = 1};};
00786
00787         template <typename T, typename S,
00788             typename P01, typename P02, typename P03, typename P04, typename P05,
00789             typename P06, typename P07, typename P08, typename P09, typename P10>
00790         struct IsMemberFunctionPointerRaw<T (S::*)(
00791             P01, P02, P03, P04, P05,
00792             P06, P07, P08, P09, P10,
00793             ...)>
00794         {enum {result = 1};};
00795
00796         template <typename T, typename S,
00797             typename P01, typename P02, typename P03, typename P04, typename P05,
00798             typename P06, typename P07, typename P08, typename P09, typename P10,
00799             typename P11>
00800         struct IsMemberFunctionPointerRaw<T (S::*)(
00801             P01, P02, P03, P04, P05,
00802             P06, P07, P08, P09, P10,
00803             P11, ...)>
00804         {enum {result = 1};};
00805
00806         template <typename T, typename S,
00807             typename P01, typename P02, typename P03, typename P04, typename P05,
00808             typename P06, typename P07, typename P08, typename P09, typename P10,
00809             typename P11, typename P12>
00810         struct IsMemberFunctionPointerRaw<T (S::*)(
00811             P01, P02, P03, P04, P05,
00812             P06, P07, P08, P09, P10,
00813             P11, P12, ...)>
00814         {enum {result = 1};};
00815
00816         template <typename T, typename S,
00817             typename P01, typename P02, typename P03, typename P04, typename P05,
00818             typename P06, typename P07, typename P08, typename P09, typename P10,
00819             typename P11, typename P12, typename P13>
00820         struct IsMemberFunctionPointerRaw<T (S::*)(
00821             P01, P02, P03, P04, P05,
00822             P06, P07, P08, P09, P10,
00823             P11, P12, P13, ...)>
00824         {enum {result = 1};};
00825
00826         template <typename T, typename S,
00827             typename P01, typename P02, typename P03, typename P04, typename P05,
00828             typename P06, typename P07, typename P08, typename P09, typename P10,
00829             typename P11, typename P12, typename P13, typename P14>
00830         struct IsMemberFunctionPointerRaw<T (S::*)(
00831             P01, P02, P03, P04, P05,
00832             P06, P07, P08, P09, P10,
00833             P11, P12, P13, P14, ...)>
00834         {enum {result = 1};};
00835
00836         template <typename T, typename S,
00837             typename P01, typename P02, typename P03, typename P04, typename P05,
00838             typename P06, typename P07, typename P08, typename P09, typename P10,
00839             typename P11, typename P12, typename P13, typename P14, typename P15>
00840         struct IsMemberFunctionPointerRaw<T (S::*)(
00841             P01, P02, P03, P04, P05,
00842             P06, P07, P08, P09, P10,
00843             P11, P12, P13, P14, P15,
00844             ...)>
00845         {enum {result = 1};};
00846
00847         template <typename T, typename S,
00848             typename P01, typename P02, typename P03, typename P04, typename P05,
00849             typename P06, typename P07, typename P08, typename P09, typename P10,
00850             typename P11, typename P12, typename P13, typename P14, typename P15,
00851             typename P16>
00852         struct IsMemberFunctionPointerRaw<T (S::*)(
00853             P01, P02, P03, P04, P05,
00854             P06, P07, P08, P09, P10,
00855             P11, P12, P13, P14, P15,
00856             P16, ...)>
00857         {enum {result = 1};};
00858
00859         template <typename T, typename S,
00860             typename P01, typename P02, typename P03, typename P04, typename P05,
00861             typename P06, typename P07, typename P08, typename P09, typename P10,
00862             typename P11, typename P12, typename P13, typename P14, typename P15,
00863             typename P16, typename P17>
00864         struct IsMemberFunctionPointerRaw<T (S::*)(
00865             P01, P02, P03, P04, P05,
00866             P06, P07, P08, P09, P10,
00867             P11, P12, P13, P14, P15,
00868             P16, P17, ...)>
00869         {enum {result = 1};};
00870
00871         template <typename T, typename S,
00872             typename P01, typename P02, typename P03, typename P04, typename P05,
00873             typename P06, typename P07, typename P08, typename P09, typename P10,
00874             typename P11, typename P12, typename P13, typename P14, typename P15,
00875             typename P16, typename P17, typename P18>
00876         struct IsMemberFunctionPointerRaw<T (S::*)(
00877             P01, P02, P03, P04, P05,
00878             P06, P07, P08, P09, P10,
00879             P11, P12, P13, P14, P15,
00880             P16, P17, P18, ...)>
00881         {enum {result = 1};};
00882
00883         template <typename T, typename S,
00884             typename P01, typename P02, typename P03, typename P04, typename P05,
00885             typename P06, typename P07, typename P08, typename P09, typename P10,
00886             typename P11, typename P12, typename P13, typename P14, typename P15,
00887             typename P16, typename P17, typename P18, typename P19>
00888         struct IsMemberFunctionPointerRaw<T (S::*)(
00889             P01, P02, P03, P04, P05,
00890             P06, P07, P08, P09, P10,
00891             P11, P12, P13, P14, P15,
00892             P16, P17, P18, P19, ...)>
00893         {enum {result = 1};};
00894
00895         template <typename T, typename S,
00896             typename P01, typename P02, typename P03, typename P04, typename P05,
00897             typename P06, typename P07, typename P08, typename P09, typename P10,
00898             typename P11, typename P12, typename P13, typename P14, typename P15,
00899             typename P16, typename P17, typename P18, typename P19, typename P20>
00900         struct IsMemberFunctionPointerRaw<T (S::*)(
00901             P01, P02, P03, P04, P05,
00902             P06, P07, P08, P09, P10,
00903             P11, P12, P13, P14, P15,
00904             P16, P17, P18, P19, P20,
00905             ...)>
00906         {enum {result = 1};};
00907
00908         // Const versions
00909
00910         template <typename T, typename S>
00911         struct IsMemberFunctionPointerRaw<T (S::*)() const>
00912         {enum {result = 1};};
00913
00914         template <typename T, typename S,
00915             typename P01>
00916         struct IsMemberFunctionPointerRaw<T (S::*)(P01) const>
00917         {enum {result = 1};};
00918
00919         template <typename T, typename S,
00920             typename P01, typename P02>
00921         struct IsMemberFunctionPointerRaw<T (S::*)(
00922             P01, P02) const>
00923         {enum {result = 1};};
00924
00925         template <typename T, typename S,
00926             typename P01, typename P02, typename P03>
00927         struct IsMemberFunctionPointerRaw<T (S::*)(
00928             P01, P02, P03) const>
00929         {enum {result = 1};};
00930
00931         template <typename T, typename S,
00932             typename P01, typename P02, typename P03, typename P04>
00933         struct IsMemberFunctionPointerRaw<T (S::*)(
00934             P01, P02, P03, P04) const>
00935         {enum {result = 1};};
00936
00937         template <typename T, typename S,
00938             typename P01, typename P02, typename P03, typename P04, typename P05>
00939         struct IsMemberFunctionPointerRaw<T (S::*)(
00940             P01, P02, P03, P04, P05) const>
00941         {enum {result = 1};};
00942
00943         template <typename T, typename S,
00944             typename P01, typename P02, typename P03, typename P04, typename P05,
00945             typename P06>
00946         struct IsMemberFunctionPointerRaw<T (S::*)(
00947             P01, P02, P03, P04, P05,
00948             P06) const>
00949         {enum {result = 1};};
00950
00951         template <typename T, typename S,
00952             typename P01, typename P02, typename P03, typename P04, typename P05,
00953             typename P06, typename P07>
00954         struct IsMemberFunctionPointerRaw<T (S::*)(
00955             P01, P02, P03, P04, P05,
00956             P06, P07) const>
00957         {enum {result = 1};};
00958
00959         template <typename T, typename S,
00960             typename P01, typename P02, typename P03, typename P04, typename P05,
00961             typename P06, typename P07, typename P08>
00962         struct IsMemberFunctionPointerRaw<T (S::*)(
00963             P01, P02, P03, P04, P05,
00964             P06, P07, P08) const>
00965         {enum {result = 1};};
00966
00967         template <typename T, typename S,
00968             typename P01, typename P02, typename P03, typename P04, typename P05,
00969             typename P06, typename P07, typename P08, typename P09>
00970         struct IsMemberFunctionPointerRaw<T (S::*)(
00971             P01, P02, P03, P04, P05,
00972             P06, P07, P08, P09) const>
00973         {enum {result = 1};};
00974
00975         template <typename T, typename S,
00976             typename P01, typename P02, typename P03, typename P04, typename P05,
00977             typename P06, typename P07, typename P08, typename P09, typename P10>
00978         struct IsMemberFunctionPointerRaw<T (S::*)(
00979             P01, P02, P03, P04, P05,
00980             P06, P07, P08, P09, P10) const>
00981         {enum {result = 1};};
00982
00983         template <typename T, typename S,
00984             typename P01, typename P02, typename P03, typename P04, typename P05,
00985             typename P06, typename P07, typename P08, typename P09, typename P10,
00986             typename P11>
00987         struct IsMemberFunctionPointerRaw<T (S::*)(
00988             P01, P02, P03, P04, P05,
00989             P06, P07, P08, P09, P10,
00990             P11) const>
00991         {enum {result = 1};};
00992
00993         template <typename T, typename S,
00994             typename P01, typename P02, typename P03, typename P04, typename P05,
00995             typename P06, typename P07, typename P08, typename P09, typename P10,
00996             typename P11, typename P12>
00997         struct IsMemberFunctionPointerRaw<T (S::*)(
00998             P01, P02, P03, P04, P05,
00999             P06, P07, P08, P09, P10,
01000             P11, P12) const>
01001         {enum {result = 1};};
01002
01003         template <typename T, typename S,
01004             typename P01, typename P02, typename P03, typename P04, typename P05,
01005             typename P06, typename P07, typename P08, typename P09, typename P10,
01006             typename P11, typename P12, typename P13>
01007         struct IsMemberFunctionPointerRaw<T (S::*)(
01008             P01, P02, P03, P04, P05,
01009             P06, P07, P08, P09, P10,
01010             P11, P12, P13) const>
01011         {enum {result = 1};};
01012
01013         template <typename T, typename S,
01014             typename P01, typename P02, typename P03, typename P04, typename P05,
01015             typename P06, typename P07, typename P08, typename P09, typename P10,
01016             typename P11, typename P12, typename P13, typename P14>
01017         struct IsMemberFunctionPointerRaw<T (S::*)(
01018             P01, P02, P03, P04, P05,
01019             P06, P07, P08, P09, P10,
01020             P11, P12, P13, P14) const>
01021         {enum {result = 1};};
01022
01023         template <typename T, typename S,
01024             typename P01, typename P02, typename P03, typename P04, typename P05,
01025             typename P06, typename P07, typename P08, typename P09, typename P10,
01026             typename P11, typename P12, typename P13, typename P14, typename P15>
01027         struct IsMemberFunctionPointerRaw<T (S::*)(
01028             P01, P02, P03, P04, P05,
01029             P06, P07, P08, P09, P10,
01030             P11, P12, P13, P14, P15) const>
01031         {enum {result = 1};};
01032
01033         template <typename T, typename S,
01034             typename P01, typename P02, typename P03, typename P04, typename P05,
01035             typename P06, typename P07, typename P08, typename P09, typename P10,
01036             typename P11, typename P12, typename P13, typename P14, typename P15,
01037             typename P16>
01038         struct IsMemberFunctionPointerRaw<T (S::*)(
01039             P01, P02, P03, P04, P05,
01040             P06, P07, P08, P09, P10,
01041             P11, P12, P13, P14, P15,
01042             P16) const>
01043         {enum {result = 1};};
01044
01045         template <typename T, typename S,
01046             typename P01, typename P02, typename P03, typename P04, typename P05,
01047             typename P06, typename P07, typename P08, typename P09, typename P10,
01048             typename P11, typename P12, typename P13, typename P14, typename P15,
01049             typename P16, typename P17>
01050         struct IsMemberFunctionPointerRaw<T (S::*)(
01051             P01, P02, P03, P04, P05,
01052             P06, P07, P08, P09, P10,
01053             P11, P12, P13, P14, P15,
01054             P16, P17) const>
01055         {enum {result = 1};};
01056
01057         template <typename T, typename S,
01058             typename P01, typename P02, typename P03, typename P04, typename P05,
01059             typename P06, typename P07, typename P08, typename P09, typename P10,
01060             typename P11, typename P12, typename P13, typename P14, typename P15,
01061             typename P16, typename P17, typename P18>
01062         struct IsMemberFunctionPointerRaw<T (S::*)(
01063             P01, P02, P03, P04, P05,
01064             P06, P07, P08, P09, P10,
01065             P11, P12, P13, P14, P15,
01066             P16, P17, P18) const>
01067         {enum {result = 1};};
01068
01069         template <typename T, typename S,
01070             typename P01, typename P02, typename P03, typename P04, typename P05,
01071             typename P06, typename P07, typename P08, typename P09, typename P10,
01072             typename P11, typename P12, typename P13, typename P14, typename P15,
01073             typename P16, typename P17, typename P18, typename P19>
01074         struct IsMemberFunctionPointerRaw<T (S::*)(
01075             P01, P02, P03, P04, P05,
01076             P06, P07, P08, P09, P10,
01077             P11, P12, P13, P14, P15,
01078             P16, P17, P18, P19) const>
01079         {enum {result = 1};};
01080
01081         template <typename T, typename S,
01082             typename P01, typename P02, typename P03, typename P04, typename P05,
01083             typename P06, typename P07, typename P08, typename P09, typename P10,
01084             typename P11, typename P12, typename P13, typename P14, typename P15,
01085             typename P16, typename P17, typename P18, typename P19, typename P20>
01086         struct IsMemberFunctionPointerRaw<T (S::*)(
01087             P01, P02, P03, P04, P05,
01088             P06, P07, P08, P09, P10,
01089             P11, P12, P13, P14, P15,
01090             P16, P17, P18, P19, P20) const>
01091         {enum {result = 1};};
01092
01093         template <typename T, typename S>
01094         struct IsMemberFunctionPointerRaw<T (S::*)(
01095             ...) const>
01096         {enum {result = 1};};
01097
01098         template <typename T, typename S,
01099             typename P01>
01100         struct IsMemberFunctionPointerRaw<T (S::*)(
01101             P01, ...) const>
01102         {enum {result = 1};};
01103
01104         template <typename T, typename S,
01105             typename P01, typename P02>
01106         struct IsMemberFunctionPointerRaw<T (S::*)(
01107             P01, P02, ...) const>
01108         {enum {result = 1};};
01109
01110         template <typename T, typename S,
01111             typename P01, typename P02, typename P03>
01112         struct IsMemberFunctionPointerRaw<T (S::*)(
01113             P01, P02, P03, ...) const>
01114         {enum {result = 1};};
01115
01116         template <typename T, typename S,
01117             typename P01, typename P02, typename P03, typename P04>
01118         struct IsMemberFunctionPointerRaw<T (S::*)(
01119             P01, P02, P03, P04, ...) const>
01120         {enum {result = 1};};
01121
01122         template <typename T, typename S,
01123             typename P01, typename P02, typename P03, typename P04, typename P05>
01124         struct IsMemberFunctionPointerRaw<T (S::*)(
01125             P01, P02, P03, P04, P05,
01126             ...) const>
01127         {enum {result = 1};};
01128
01129         template <typename T, typename S,
01130             typename P01, typename P02, typename P03, typename P04, typename P05,
01131             typename P06>
01132         struct IsMemberFunctionPointerRaw<T (S::*)(
01133             P01, P02, P03, P04, P05,
01134             P06, ...) const>
01135         {enum {result = 1};};
01136
01137         template <typename T, typename S,
01138             typename P01, typename P02, typename P03, typename P04, typename P05,
01139             typename P06, typename P07>
01140         struct IsMemberFunctionPointerRaw<T (S::*)(
01141             P01, P02, P03, P04, P05,
01142             P06, P07, ...) const>
01143         {enum {result = 1};};
01144
01145         template <typename T, typename S,
01146             typename P01, typename P02, typename P03, typename P04, typename P05,
01147             typename P06, typename P07, typename P08>
01148         struct IsMemberFunctionPointerRaw<T (S::*)(
01149             P01, P02, P03, P04, P05,
01150             P06, P07, P08, ...) const>
01151         {enum {result = 1};};
01152
01153         template <typename T, typename S,
01154             typename P01, typename P02, typename P03, typename P04, typename P05,
01155             typename P06, typename P07, typename P08, typename P09>
01156         struct IsMemberFunctionPointerRaw<T (S::*)(
01157             P01, P02, P03, P04, P05,
01158             P06, P07, P08, P09, ...) const>
01159         {enum {result = 1};};
01160
01161         template <typename T, typename S,
01162             typename P01, typename P02, typename P03, typename P04, typename P05,
01163             typename P06, typename P07, typename P08, typename P09, typename P10>
01164         struct IsMemberFunctionPointerRaw<T (S::*)(
01165             P01, P02, P03, P04, P05,
01166             P06, P07, P08, P09, P10,
01167             ...) const>
01168         {enum {result = 1};};
01169
01170         template <typename T, typename S,
01171             typename P01, typename P02, typename P03, typename P04, typename P05,
01172             typename P06, typename P07, typename P08, typename P09, typename P10,
01173             typename P11>
01174         struct IsMemberFunctionPointerRaw<T (S::*)(
01175             P01, P02, P03, P04, P05,
01176             P06, P07, P08, P09, P10,
01177             P11, ...) const>
01178         {enum {result = 1};};
01179
01180         template <typename T, typename S,
01181             typename P01, typename P02, typename P03, typename P04, typename P05,
01182             typename P06, typename P07, typename P08, typename P09, typename P10,
01183             typename P11, typename P12>
01184         struct IsMemberFunctionPointerRaw<T (S::*)(
01185             P01, P02, P03, P04, P05,
01186             P06, P07, P08, P09, P10,
01187             P11, P12, ...) const>
01188         {enum {result = 1};};
01189
01190         template <typename T, typename S,
01191             typename P01, typename P02, typename P03, typename P04, typename P05,
01192             typename P06, typename P07, typename P08, typename P09, typename P10,
01193             typename P11, typename P12, typename P13>
01194         struct IsMemberFunctionPointerRaw<T (S::*)(
01195             P01, P02, P03, P04, P05,
01196             P06, P07, P08, P09, P10,
01197             P11, P12, P13, ...) const>
01198         {enum {result = 1};};
01199
01200         template <typename T, typename S,
01201             typename P01, typename P02, typename P03, typename P04, typename P05,
01202             typename P06, typename P07, typename P08, typename P09, typename P10,
01203             typename P11, typename P12, typename P13, typename P14>
01204         struct IsMemberFunctionPointerRaw<T (S::*)(
01205             P01, P02, P03, P04, P05,
01206             P06, P07, P08, P09, P10,
01207             P11, P12, P13, P14, ...) const>
01208         {enum {result = 1};};
01209
01210         template <typename T, typename S,
01211             typename P01, typename P02, typename P03, typename P04, typename P05,
01212             typename P06, typename P07, typename P08, typename P09, typename P10,
01213             typename P11, typename P12, typename P13, typename P14, typename P15>
01214         struct IsMemberFunctionPointerRaw<T (S::*)(
01215             P01, P02, P03, P04, P05,
01216             P06, P07, P08, P09, P10,
01217             P11, P12, P13, P14, P15,
01218             ...) const>
01219         {enum {result = 1};};
01220
01221         template <typename T, typename S,
01222             typename P01, typename P02, typename P03, typename P04, typename P05,
01223             typename P06, typename P07, typename P08, typename P09, typename P10,
01224             typename P11, typename P12, typename P13, typename P14, typename P15,
01225             typename P16>
01226         struct IsMemberFunctionPointerRaw<T (S::*)(
01227             P01, P02, P03, P04, P05,
01228             P06, P07, P08, P09, P10,
01229             P11, P12, P13, P14, P15,
01230             P16, ...) const>
01231         {enum {result = 1};};
01232
01233         template <typename T, typename S,
01234             typename P01, typename P02, typename P03, typename P04, typename P05,
01235             typename P06, typename P07, typename P08, typename P09, typename P10,
01236             typename P11, typename P12, typename P13, typename P14, typename P15,
01237             typename P16, typename P17>
01238         struct IsMemberFunctionPointerRaw<T (S::*)(
01239             P01, P02, P03, P04, P05,
01240             P06, P07, P08, P09, P10,
01241             P11, P12, P13, P14, P15,
01242             P16, P17, ...) const>
01243         {enum {result = 1};};
01244
01245         template <typename T, typename S,
01246             typename P01, typename P02, typename P03, typename P04, typename P05,
01247             typename P06, typename P07, typename P08, typename P09, typename P10,
01248             typename P11, typename P12, typename P13, typename P14, typename P15,
01249             typename P16, typename P17, typename P18>
01250         struct IsMemberFunctionPointerRaw<T (S::*)(
01251             P01, P02, P03, P04, P05,
01252             P06, P07, P08, P09, P10,
01253             P11, P12, P13, P14, P15,
01254             P16, P17, P18, ...) const>
01255         {enum {result = 1};};
01256
01257         template <typename T, typename S,
01258             typename P01, typename P02, typename P03, typename P04, typename P05,
01259             typename P06, typename P07, typename P08, typename P09, typename P10,
01260             typename P11, typename P12, typename P13, typename P14, typename P15,
01261             typename P16, typename P17, typename P18, typename P19>
01262         struct IsMemberFunctionPointerRaw<T (S::*)(
01263             P01, P02, P03, P04, P05,
01264             P06, P07, P08, P09, P10,
01265             P11, P12, P13, P14, P15,
01266             P16, P17, P18, P19, ...) const>
01267         {enum {result = 1};};
01268
01269         template <typename T, typename S,
01270             typename P01, typename P02, typename P03, typename P04, typename P05,
01271             typename P06, typename P07, typename P08, typename P09, typename P10,
01272             typename P11, typename P12, typename P13, typename P14, typename P15,
01273             typename P16, typename P17, typename P18, typename P19, typename P20>
01274         struct IsMemberFunctionPointerRaw<T (S::*)(
01275             P01, P02, P03, P04, P05,
01276             P06, P07, P08, P09, P10,
01277             P11, P12, P13, P14, P15,
01278             P16, P17, P18, P19, P20,
01279             ...) const>
01280         {enum {result = 1};};
01281
01282         // Volatile versions
01283
01284         template <typename T, typename S>
01285         struct IsMemberFunctionPointerRaw<T (S::*)() volatile>
01286         {enum {result = 1};};
01287
01288         template <typename T, typename S,
01289             typename P01>
01290         struct IsMemberFunctionPointerRaw<T (S::*)(P01) volatile>
01291         {enum {result = 1};};
01292
01293         template <typename T, typename S,
01294             typename P01, typename P02>
01295         struct IsMemberFunctionPointerRaw<T (S::*)(
01296             P01, P02) volatile>
01297         {enum {result = 1};};
01298
01299         template <typename T, typename S,
01300             typename P01, typename P02, typename P03>
01301         struct IsMemberFunctionPointerRaw<T (S::*)(
01302             P01, P02, P03) volatile>
01303         {enum {result = 1};};
01304
01305         template <typename T, typename S,
01306             typename P01, typename P02, typename P03, typename P04>
01307         struct IsMemberFunctionPointerRaw<T (S::*)(
01308             P01, P02, P03, P04) volatile>
01309         {enum {result = 1};};
01310
01311         template <typename T, typename S,
01312             typename P01, typename P02, typename P03, typename P04, typename P05>
01313         struct IsMemberFunctionPointerRaw<T (S::*)(
01314             P01, P02, P03, P04, P05) volatile>
01315         {enum {result = 1};};
01316
01317         template <typename T, typename S,
01318             typename P01, typename P02, typename P03, typename P04, typename P05,
01319             typename P06>
01320         struct IsMemberFunctionPointerRaw<T (S::*)(
01321             P01, P02, P03, P04, P05,
01322             P06) volatile>
01323         {enum {result = 1};};
01324
01325         template <typename T, typename S,
01326             typename P01, typename P02, typename P03, typename P04, typename P05,
01327             typename P06, typename P07>
01328         struct IsMemberFunctionPointerRaw<T (S::*)(
01329             P01, P02, P03, P04, P05,
01330             P06, P07) volatile>
01331         {enum {result = 1};};
01332
01333         template <typename T, typename S,
01334             typename P01, typename P02, typename P03, typename P04, typename P05,
01335             typename P06, typename P07, typename P08>
01336         struct IsMemberFunctionPointerRaw<T (S::*)(
01337             P01, P02, P03, P04, P05,
01338             P06, P07, P08) volatile>
01339         {enum {result = 1};};
01340
01341         template <typename T, typename S,
01342             typename P01, typename P02, typename P03, typename P04, typename P05,
01343             typename P06, typename P07, typename P08, typename P09>
01344         struct IsMemberFunctionPointerRaw<T (S::*)(
01345             P01, P02, P03, P04, P05,
01346             P06, P07, P08, P09) volatile>
01347         {enum {result = 1};};
01348
01349         template <typename T, typename S,
01350             typename P01, typename P02, typename P03, typename P04, typename P05,
01351             typename P06, typename P07, typename P08, typename P09, typename P10>
01352         struct IsMemberFunctionPointerRaw<T (S::*)(
01353             P01, P02, P03, P04, P05,
01354             P06, P07, P08, P09, P10) volatile>
01355         {enum {result = 1};};
01356
01357         template <typename T, typename S,
01358             typename P01, typename P02, typename P03, typename P04, typename P05,
01359             typename P06, typename P07, typename P08, typename P09, typename P10,
01360             typename P11>
01361         struct IsMemberFunctionPointerRaw<T (S::*)(
01362             P01, P02, P03, P04, P05,
01363             P06, P07, P08, P09, P10,
01364             P11) volatile>
01365         {enum {result = 1};};
01366
01367         template <typename T, typename S,
01368             typename P01, typename P02, typename P03, typename P04, typename P05,
01369             typename P06, typename P07, typename P08, typename P09, typename P10,
01370             typename P11, typename P12>
01371         struct IsMemberFunctionPointerRaw<T (S::*)(
01372             P01, P02, P03, P04, P05,
01373             P06, P07, P08, P09, P10,
01374             P11, P12) volatile>
01375         {enum {result = 1};};
01376
01377         template <typename T, typename S,
01378             typename P01, typename P02, typename P03, typename P04, typename P05,
01379             typename P06, typename P07, typename P08, typename P09, typename P10,
01380             typename P11, typename P12, typename P13>
01381         struct IsMemberFunctionPointerRaw<T (S::*)(
01382             P01, P02, P03, P04, P05,
01383             P06, P07, P08, P09, P10,
01384             P11, P12, P13) volatile>
01385         {enum {result = 1};};
01386
01387         template <typename T, typename S,
01388             typename P01, typename P02, typename P03, typename P04, typename P05,
01389             typename P06, typename P07, typename P08, typename P09, typename P10,
01390             typename P11, typename P12, typename P13, typename P14>
01391         struct IsMemberFunctionPointerRaw<T (S::*)(
01392             P01, P02, P03, P04, P05,
01393             P06, P07, P08, P09, P10,
01394             P11, P12, P13, P14) volatile>
01395         {enum {result = 1};};
01396
01397         template <typename T, typename S,
01398             typename P01, typename P02, typename P03, typename P04, typename P05,
01399             typename P06, typename P07, typename P08, typename P09, typename P10,
01400             typename P11, typename P12, typename P13, typename P14, typename P15>
01401         struct IsMemberFunctionPointerRaw<T (S::*)(
01402             P01, P02, P03, P04, P05,
01403             P06, P07, P08, P09, P10,
01404             P11, P12, P13, P14, P15) volatile>
01405         {enum {result = 1};};
01406
01407         template <typename T, typename S,
01408             typename P01, typename P02, typename P03, typename P04, typename P05,
01409             typename P06, typename P07, typename P08, typename P09, typename P10,
01410             typename P11, typename P12, typename P13, typename P14, typename P15,
01411             typename P16>
01412         struct IsMemberFunctionPointerRaw<T (S::*)(
01413             P01, P02, P03, P04, P05,
01414             P06, P07, P08, P09, P10,
01415             P11, P12, P13, P14, P15,
01416             P16) volatile>
01417         {enum {result = 1};};
01418
01419         template <typename T, typename S,
01420             typename P01, typename P02, typename P03, typename P04, typename P05,
01421             typename P06, typename P07, typename P08, typename P09, typename P10,
01422             typename P11, typename P12, typename P13, typename P14, typename P15,
01423             typename P16, typename P17>
01424         struct IsMemberFunctionPointerRaw<T (S::*)(
01425             P01, P02, P03, P04, P05,
01426             P06, P07, P08, P09, P10,
01427             P11, P12, P13, P14, P15,
01428             P16, P17) volatile>
01429         {enum {result = 1};};
01430
01431         template <typename T, typename S,
01432             typename P01, typename P02, typename P03, typename P04, typename P05,
01433             typename P06, typename P07, typename P08, typename P09, typename P10,
01434             typename P11, typename P12, typename P13, typename P14, typename P15,
01435             typename P16, typename P17, typename P18>
01436         struct IsMemberFunctionPointerRaw<T (S::*)(
01437             P01, P02, P03, P04, P05,
01438             P06, P07, P08, P09, P10,
01439             P11, P12, P13, P14, P15,
01440             P16, P17, P18) volatile>
01441         {enum {result = 1};};
01442
01443         template <typename T, typename S,
01444             typename P01, typename P02, typename P03, typename P04, typename P05,
01445             typename P06, typename P07, typename P08, typename P09, typename P10,
01446             typename P11, typename P12, typename P13, typename P14, typename P15,
01447             typename P16, typename P17, typename P18, typename P19>
01448         struct IsMemberFunctionPointerRaw<T (S::*)(
01449             P01, P02, P03, P04, P05,
01450             P06, P07, P08, P09, P10,
01451             P11, P12, P13, P14, P15,
01452             P16, P17, P18, P19) volatile>
01453         {enum {result = 1};};
01454
01455         template <typename T, typename S,
01456             typename P01, typename P02, typename P03, typename P04, typename P05,
01457             typename P06, typename P07, typename P08, typename P09, typename P10,
01458             typename P11, typename P12, typename P13, typename P14, typename P15,
01459             typename P16, typename P17, typename P18, typename P19, typename P20>
01460         struct IsMemberFunctionPointerRaw<T (S::*)(
01461             P01, P02, P03, P04, P05,
01462             P06, P07, P08, P09, P10,
01463             P11, P12, P13, P14, P15,
01464             P16, P17, P18, P19, P20) volatile>
01465         {enum {result = 1};};
01466
01467         template <typename T, typename S>
01468         struct IsMemberFunctionPointerRaw<T (S::*)(
01469             ...) volatile>
01470         {enum {result = 1};};
01471
01472         template <typename T, typename S,
01473             typename P01>
01474         struct IsMemberFunctionPointerRaw<T (S::*)(
01475             P01, ...) volatile>
01476         {enum {result = 1};};
01477
01478         template <typename T, typename S,
01479             typename P01, typename P02>
01480         struct IsMemberFunctionPointerRaw<T (S::*)(
01481             P01, P02, ...) volatile>
01482         {enum {result = 1};};
01483
01484         template <typename T, typename S,
01485             typename P01, typename P02, typename P03>
01486         struct IsMemberFunctionPointerRaw<T (S::*)(
01487             P01, P02, P03, ...) volatile>
01488         {enum {result = 1};};
01489
01490         template <typename T, typename S,
01491             typename P01, typename P02, typename P03, typename P04>
01492         struct IsMemberFunctionPointerRaw<T (S::*)(
01493             P01, P02, P03, P04, ...) volatile>
01494         {enum {result = 1};};
01495
01496         template <typename T, typename S,
01497             typename P01, typename P02, typename P03, typename P04, typename P05>
01498         struct IsMemberFunctionPointerRaw<T (S::*)(
01499             P01, P02, P03, P04, P05,
01500             ...) volatile>
01501         {enum {result = 1};};
01502
01503         template <typename T, typename S,
01504             typename P01, typename P02, typename P03, typename P04, typename P05,
01505             typename P06>
01506         struct IsMemberFunctionPointerRaw<T (S::*)(
01507             P01, P02, P03, P04, P05,
01508             P06, ...) volatile>
01509         {enum {result = 1};};
01510
01511         template <typename T, typename S,
01512             typename P01, typename P02, typename P03, typename P04, typename P05,
01513             typename P06, typename P07>
01514         struct IsMemberFunctionPointerRaw<T (S::*)(
01515             P01, P02, P03, P04, P05,
01516             P06, P07, ...) volatile>
01517         {enum {result = 1};};
01518
01519         template <typename T, typename S,
01520             typename P01, typename P02, typename P03, typename P04, typename P05,
01521             typename P06, typename P07, typename P08>
01522         struct IsMemberFunctionPointerRaw<T (S::*)(
01523             P01, P02, P03, P04, P05,
01524             P06, P07, P08, ...) volatile>
01525         {enum {result = 1};};
01526
01527         template <typename T, typename S,
01528             typename P01, typename P02, typename P03, typename P04, typename P05,
01529             typename P06, typename P07, typename P08, typename P09>
01530         struct IsMemberFunctionPointerRaw<T (S::*)(
01531             P01, P02, P03, P04, P05,
01532             P06, P07, P08, P09, ...) volatile>
01533         {enum {result = 1};};
01534
01535         template <typename T, typename S,
01536             typename P01, typename P02, typename P03, typename P04, typename P05,
01537             typename P06, typename P07, typename P08, typename P09, typename P10>
01538         struct IsMemberFunctionPointerRaw<T (S::*)(
01539             P01, P02, P03, P04, P05,
01540             P06, P07, P08, P09, P10,
01541             ...) volatile>
01542         {enum {result = 1};};
01543
01544         template <typename T, typename S,
01545             typename P01, typename P02, typename P03, typename P04, typename P05,
01546             typename P06, typename P07, typename P08, typename P09, typename P10,
01547             typename P11>
01548         struct IsMemberFunctionPointerRaw<T (S::*)(
01549             P01, P02, P03, P04, P05,
01550             P06, P07, P08, P09, P10,
01551             P11, ...) volatile>
01552         {enum {result = 1};};
01553
01554         template <typename T, typename S,
01555             typename P01, typename P02, typename P03, typename P04, typename P05,
01556             typename P06, typename P07, typename P08, typename P09, typename P10,
01557             typename P11, typename P12>
01558         struct IsMemberFunctionPointerRaw<T (S::*)(
01559             P01, P02, P03, P04, P05,
01560             P06, P07, P08, P09, P10,
01561             P11, P12, ...) volatile>
01562         {enum {result = 1};};
01563
01564         template <typename T, typename S,
01565             typename P01, typename P02, typename P03, typename P04, typename P05,
01566             typename P06, typename P07, typename P08, typename P09, typename P10,
01567             typename P11, typename P12, typename P13>
01568         struct IsMemberFunctionPointerRaw<T (S::*)(
01569             P01, P02, P03, P04, P05,
01570             P06, P07, P08, P09, P10,
01571             P11, P12, P13, ...) volatile>
01572         {enum {result = 1};};
01573
01574         template <typename T, typename S,
01575             typename P01, typename P02, typename P03, typename P04, typename P05,
01576             typename P06, typename P07, typename P08, typename P09, typename P10,
01577             typename P11, typename P12, typename P13, typename P14>
01578         struct IsMemberFunctionPointerRaw<T (S::*)(
01579             P01, P02, P03, P04, P05,
01580             P06, P07, P08, P09, P10,
01581             P11, P12, P13, P14, ...) volatile>
01582         {enum {result = 1};};
01583
01584         template <typename T, typename S,
01585             typename P01, typename P02, typename P03, typename P04, typename P05,
01586             typename P06, typename P07, typename P08, typename P09, typename P10,
01587             typename P11, typename P12, typename P13, typename P14, typename P15>
01588         struct IsMemberFunctionPointerRaw<T (S::*)(
01589             P01, P02, P03, P04, P05,
01590             P06, P07, P08, P09, P10,
01591             P11, P12, P13, P14, P15,
01592             ...) volatile>
01593         {enum {result = 1};};
01594
01595         template <typename T, typename S,
01596             typename P01, typename P02, typename P03, typename P04, typename P05,
01597             typename P06, typename P07, typename P08, typename P09, typename P10,
01598             typename P11, typename P12, typename P13, typename P14, typename P15,
01599             typename P16>
01600         struct IsMemberFunctionPointerRaw<T (S::*)(
01601             P01, P02, P03, P04, P05,
01602             P06, P07, P08, P09, P10,
01603             P11, P12, P13, P14, P15,
01604             P16, ...) volatile>
01605         {enum {result = 1};};
01606
01607         template <typename T, typename S,
01608             typename P01, typename P02, typename P03, typename P04, typename P05,
01609             typename P06, typename P07, typename P08, typename P09, typename P10,
01610             typename P11, typename P12, typename P13, typename P14, typename P15,
01611             typename P16, typename P17>
01612         struct IsMemberFunctionPointerRaw<T (S::*)(
01613             P01, P02, P03, P04, P05,
01614             P06, P07, P08, P09, P10,
01615             P11, P12, P13, P14, P15,
01616             P16, P17, ...) volatile>
01617         {enum {result = 1};};
01618
01619         template <typename T, typename S,
01620             typename P01, typename P02, typename P03, typename P04, typename P05,
01621             typename P06, typename P07, typename P08, typename P09, typename P10,
01622             typename P11, typename P12, typename P13, typename P14, typename P15,
01623             typename P16, typename P17, typename P18>
01624         struct IsMemberFunctionPointerRaw<T (S::*)(
01625             P01, P02, P03, P04, P05,
01626             P06, P07, P08, P09, P10,
01627             P11, P12, P13, P14, P15,
01628             P16, P17, P18, ...) volatile>
01629         {enum {result = 1};};
01630
01631         template <typename T, typename S,
01632             typename P01, typename P02, typename P03, typename P04, typename P05,
01633             typename P06, typename P07, typename P08, typename P09, typename P10,
01634             typename P11, typename P12, typename P13, typename P14, typename P15,
01635             typename P16, typename P17, typename P18, typename P19>
01636         struct IsMemberFunctionPointerRaw<T (S::*)(
01637             P01, P02, P03, P04, P05,
01638             P06, P07, P08, P09, P10,
01639             P11, P12, P13, P14, P15,
01640             P16, P17, P18, P19, ...) volatile>
01641         {enum {result = 1};};
01642
01643         template <typename T, typename S,
01644             typename P01, typename P02, typename P03, typename P04, typename P05,
01645             typename P06, typename P07, typename P08, typename P09, typename P10,
01646             typename P11, typename P12, typename P13, typename P14, typename P15,
01647             typename P16, typename P17, typename P18, typename P19, typename P20>
01648         struct IsMemberFunctionPointerRaw<T (S::*)(
01649             P01, P02, P03, P04, P05,
01650             P06, P07, P08, P09, P10,
01651             P11, P12, P13, P14, P15,
01652             P16, P17, P18, P19, P20,
01653             ...) volatile>
01654         {enum {result = 1};};
01655
01656         // Const volatile versions
01657
01658         template <typename T, typename S>
01659         struct IsMemberFunctionPointerRaw<T (S::*)() const volatile>
01660         {enum {result = 1};};
01661
01662         template <typename T, typename S,
01663             typename P01>
01664         struct IsMemberFunctionPointerRaw<T (S::*)(P01) const volatile>
01665         {enum {result = 1};};
01666
01667         template <typename T, typename S,
01668             typename P01, typename P02>
01669         struct IsMemberFunctionPointerRaw<T (S::*)(
01670             P01, P02) const volatile>
01671         {enum {result = 1};};
01672
01673         template <typename T, typename S,
01674             typename P01, typename P02, typename P03>
01675         struct IsMemberFunctionPointerRaw<T (S::*)(
01676             P01, P02, P03) const volatile>
01677         {enum {result = 1};};
01678
01679         template <typename T, typename S,
01680             typename P01, typename P02, typename P03, typename P04>
01681         struct IsMemberFunctionPointerRaw<T (S::*)(
01682             P01, P02, P03, P04) const volatile>
01683         {enum {result = 1};};
01684
01685         template <typename T, typename S,
01686             typename P01, typename P02, typename P03, typename P04, typename P05>
01687         struct IsMemberFunctionPointerRaw<T (S::*)(
01688             P01, P02, P03, P04, P05) const volatile>
01689         {enum {result = 1};};
01690
01691         template <typename T, typename S,
01692             typename P01, typename P02, typename P03, typename P04, typename P05,
01693             typename P06>
01694         struct IsMemberFunctionPointerRaw<T (S::*)(
01695             P01, P02, P03, P04, P05,
01696             P06) const volatile>
01697         {enum {result = 1};};
01698
01699         template <typename T, typename S,
01700             typename P01, typename P02, typename P03, typename P04, typename P05,
01701             typename P06, typename P07>
01702         struct IsMemberFunctionPointerRaw<T (S::*)(
01703             P01, P02, P03, P04, P05,
01704             P06, P07) const volatile>
01705         {enum {result = 1};};
01706
01707         template <typename T, typename S,
01708             typename P01, typename P02, typename P03, typename P04, typename P05,
01709             typename P06, typename P07, typename P08>
01710         struct IsMemberFunctionPointerRaw<T (S::*)(
01711             P01, P02, P03, P04, P05,
01712             P06, P07, P08) const volatile>
01713         {enum {result = 1};};
01714
01715         template <typename T, typename S,
01716             typename P01, typename P02, typename P03, typename P04, typename P05,
01717             typename P06, typename P07, typename P08, typename P09>
01718         struct IsMemberFunctionPointerRaw<T (S::*)(
01719             P01, P02, P03, P04, P05,
01720             P06, P07, P08, P09) const volatile>
01721         {enum {result = 1};};
01722
01723         template <typename T, typename S,
01724             typename P01, typename P02, typename P03, typename P04, typename P05,
01725             typename P06, typename P07, typename P08, typename P09, typename P10>
01726         struct IsMemberFunctionPointerRaw<T (S::*)(
01727             P01, P02, P03, P04, P05,
01728             P06, P07, P08, P09, P10) const volatile>
01729         {enum {result = 1};};
01730
01731         template <typename T, typename S,
01732             typename P01, typename P02, typename P03, typename P04, typename P05,
01733             typename P06, typename P07, typename P08, typename P09, typename P10,
01734             typename P11>
01735         struct IsMemberFunctionPointerRaw<T (S::*)(
01736             P01, P02, P03, P04, P05,
01737             P06, P07, P08, P09, P10,
01738             P11) const volatile>
01739         {enum {result = 1};};
01740
01741         template <typename T, typename S,
01742             typename P01, typename P02, typename P03, typename P04, typename P05,
01743             typename P06, typename P07, typename P08, typename P09, typename P10,
01744             typename P11, typename P12>
01745         struct IsMemberFunctionPointerRaw<T (S::*)(
01746             P01, P02, P03, P04, P05,
01747             P06, P07, P08, P09, P10,
01748             P11, P12) const volatile>
01749         {enum {result = 1};};
01750
01751         template <typename T, typename S,
01752             typename P01, typename P02, typename P03, typename P04, typename P05,
01753             typename P06, typename P07, typename P08, typename P09, typename P10,
01754             typename P11, typename P12, typename P13>
01755         struct IsMemberFunctionPointerRaw<T (S::*)(
01756             P01, P02, P03, P04, P05,
01757             P06, P07, P08, P09, P10,
01758             P11, P12, P13) const volatile>
01759         {enum {result = 1};};
01760
01761         template <typename T, typename S,
01762             typename P01, typename P02, typename P03, typename P04, typename P05,
01763             typename P06, typename P07, typename P08, typename P09, typename P10,
01764             typename P11, typename P12, typename P13, typename P14>
01765         struct IsMemberFunctionPointerRaw<T (S::*)(
01766             P01, P02, P03, P04, P05,
01767             P06, P07, P08, P09, P10,
01768             P11, P12, P13, P14) const volatile>
01769         {enum {result = 1};};
01770
01771         template <typename T, typename S,
01772             typename P01, typename P02, typename P03, typename P04, typename P05,
01773             typename P06, typename P07, typename P08, typename P09, typename P10,
01774             typename P11, typename P12, typename P13, typename P14, typename P15>
01775         struct IsMemberFunctionPointerRaw<T (S::*)(
01776             P01, P02, P03, P04, P05,
01777             P06, P07, P08, P09, P10,
01778             P11, P12, P13, P14, P15) const volatile>
01779         {enum {result = 1};};
01780
01781         template <typename T, typename S,
01782             typename P01, typename P02, typename P03, typename P04, typename P05,
01783             typename P06, typename P07, typename P08, typename P09, typename P10,
01784             typename P11, typename P12, typename P13, typename P14, typename P15,
01785             typename P16>
01786         struct IsMemberFunctionPointerRaw<T (S::*)(
01787             P01, P02, P03, P04, P05,
01788             P06, P07, P08, P09, P10,
01789             P11, P12, P13, P14, P15,
01790             P16) const volatile>
01791         {enum {result = 1};};
01792
01793         template <typename T, typename S,
01794             typename P01, typename P02, typename P03, typename P04, typename P05,
01795             typename P06, typename P07, typename P08, typename P09, typename P10,
01796             typename P11, typename P12, typename P13, typename P14, typename P15,
01797             typename P16, typename P17>
01798         struct IsMemberFunctionPointerRaw<T (S::*)(
01799             P01, P02, P03, P04, P05,
01800             P06, P07, P08, P09, P10,
01801             P11, P12, P13, P14, P15,
01802             P16, P17) const volatile>
01803         {enum {result = 1};};
01804
01805         template <typename T, typename S,
01806             typename P01, typename P02, typename P03, typename P04, typename P05,
01807             typename P06, typename P07, typename P08, typename P09, typename P10,
01808             typename P11, typename P12, typename P13, typename P14, typename P15,
01809             typename P16, typename P17, typename P18>
01810         struct IsMemberFunctionPointerRaw<T (S::*)(
01811             P01, P02, P03, P04, P05,
01812             P06, P07, P08, P09, P10,
01813             P11, P12, P13, P14, P15,
01814             P16, P17, P18) const volatile>
01815         {enum {result = 1};};
01816
01817         template <typename T, typename S,
01818             typename P01, typename P02, typename P03, typename P04, typename P05,
01819             typename P06, typename P07, typename P08, typename P09, typename P10,
01820             typename P11, typename P12, typename P13, typename P14, typename P15,
01821             typename P16, typename P17, typename P18, typename P19>
01822         struct IsMemberFunctionPointerRaw<T (S::*)(
01823             P01, P02, P03, P04, P05,
01824             P06, P07, P08, P09, P10,
01825             P11, P12, P13, P14, P15,
01826             P16, P17, P18, P19) const volatile>
01827         {enum {result = 1};};
01828
01829         template <typename T, typename S,
01830             typename P01, typename P02, typename P03, typename P04, typename P05,
01831             typename P06, typename P07, typename P08, typename P09, typename P10,
01832             typename P11, typename P12, typename P13, typename P14, typename P15,
01833             typename P16, typename P17, typename P18, typename P19, typename P20>
01834         struct IsMemberFunctionPointerRaw<T (S::*)(
01835             P01, P02, P03, P04, P05,
01836             P06, P07, P08, P09, P10,
01837             P11, P12, P13, P14, P15,
01838             P16, P17, P18, P19, P20) const volatile>
01839         {enum {result = 1};};
01840
01841         template <typename T, typename S>
01842         struct IsMemberFunctionPointerRaw<T (S::*)(
01843             ...) const volatile>
01844         {enum {result = 1};};
01845
01846         template <typename T, typename S,
01847             typename P01>
01848         struct IsMemberFunctionPointerRaw<T (S::*)(
01849             P01, ...) const volatile>
01850         {enum {result = 1};};
01851
01852         template <typename T, typename S,
01853             typename P01, typename P02>
01854         struct IsMemberFunctionPointerRaw<T (S::*)(
01855             P01, P02, ...) const volatile>
01856         {enum {result = 1};};
01857
01858         template <typename T, typename S,
01859             typename P01, typename P02, typename P03>
01860         struct IsMemberFunctionPointerRaw<T (S::*)(
01861             P01, P02, P03, ...) const volatile>
01862         {enum {result = 1};};
01863
01864         template <typename T, typename S,
01865             typename P01, typename P02, typename P03, typename P04>
01866         struct IsMemberFunctionPointerRaw<T (S::*)(
01867             P01, P02, P03, P04, ...) const volatile>
01868         {enum {result = 1};};
01869
01870         template <typename T, typename S,
01871             typename P01, typename P02, typename P03, typename P04, typename P05>
01872         struct IsMemberFunctionPointerRaw<T (S::*)(
01873             P01, P02, P03, P04, P05,
01874             ...) const volatile>
01875         {enum {result = 1};};
01876
01877         template <typename T, typename S,
01878             typename P01, typename P02, typename P03, typename P04, typename P05,
01879             typename P06>
01880         struct IsMemberFunctionPointerRaw<T (S::*)(
01881             P01, P02, P03, P04, P05,
01882             P06, ...) const volatile>
01883         {enum {result = 1};};
01884
01885         template <typename T, typename S,
01886             typename P01, typename P02, typename P03, typename P04, typename P05,
01887             typename P06, typename P07>
01888         struct IsMemberFunctionPointerRaw<T (S::*)(
01889             P01, P02, P03, P04, P05,
01890             P06, P07, ...) const volatile>
01891         {enum {result = 1};};
01892
01893         template <typename T, typename S,
01894             typename P01, typename P02, typename P03, typename P04, typename P05,
01895             typename P06, typename P07, typename P08>
01896         struct IsMemberFunctionPointerRaw<T (S::*)(
01897             P01, P02, P03, P04, P05,
01898             P06, P07, P08, ...) const volatile>
01899         {enum {result = 1};};
01900
01901         template <typename T, typename S,
01902             typename P01, typename P02, typename P03, typename P04, typename P05,
01903             typename P06, typename P07, typename P08, typename P09>
01904         struct IsMemberFunctionPointerRaw<T (S::*)(
01905             P01, P02, P03, P04, P05,
01906             P06, P07, P08, P09, ...) const volatile>
01907         {enum {result = 1};};
01908
01909         template <typename T, typename S,
01910             typename P01, typename P02, typename P03, typename P04, typename P05,
01911             typename P06, typename P07, typename P08, typename P09, typename P10>
01912         struct IsMemberFunctionPointerRaw<T (S::*)(
01913             P01, P02, P03, P04, P05,
01914             P06, P07, P08, P09, P10,
01915             ...) const volatile>
01916         {enum {result = 1};};
01917
01918         template <typename T, typename S,
01919             typename P01, typename P02, typename P03, typename P04, typename P05,
01920             typename P06, typename P07, typename P08, typename P09, typename P10,
01921             typename P11>
01922         struct IsMemberFunctionPointerRaw<T (S::*)(
01923             P01, P02, P03, P04, P05,
01924             P06, P07, P08, P09, P10,
01925             P11, ...) const volatile>
01926         {enum {result = 1};};
01927
01928         template <typename T, typename S,
01929             typename P01, typename P02, typename P03, typename P04, typename P05,
01930             typename P06, typename P07, typename P08, typename P09, typename P10,
01931             typename P11, typename P12>
01932         struct IsMemberFunctionPointerRaw<T (S::*)(
01933             P01, P02, P03, P04, P05,
01934             P06, P07, P08, P09, P10,
01935             P11, P12, ...) const volatile>
01936         {enum {result = 1};};
01937
01938         template <typename T, typename S,
01939             typename P01, typename P02, typename P03, typename P04, typename P05,
01940             typename P06, typename P07, typename P08, typename P09, typename P10,
01941             typename P11, typename P12, typename P13>
01942         struct IsMemberFunctionPointerRaw<T (S::*)(
01943             P01, P02, P03, P04, P05,
01944             P06, P07, P08, P09, P10,
01945             P11, P12, P13, ...) const volatile>
01946         {enum {result = 1};};
01947
01948         template <typename T, typename S,
01949             typename P01, typename P02, typename P03, typename P04, typename P05,
01950             typename P06, typename P07, typename P08, typename P09, typename P10,
01951             typename P11, typename P12, typename P13, typename P14>
01952         struct IsMemberFunctionPointerRaw<T (S::*)(
01953             P01, P02, P03, P04, P05,
01954             P06, P07, P08, P09, P10,
01955             P11, P12, P13, P14, ...) const volatile>
01956         {enum {result = 1};};
01957
01958         template <typename T, typename S,
01959             typename P01, typename P02, typename P03, typename P04, typename P05,
01960             typename P06, typename P07, typename P08, typename P09, typename P10,
01961             typename P11, typename P12, typename P13, typename P14, typename P15>
01962         struct IsMemberFunctionPointerRaw<T (S::*)(
01963             P01, P02, P03, P04, P05,
01964             P06, P07, P08, P09, P10,
01965             P11, P12, P13, P14, P15,
01966             ...) const volatile>
01967         {enum {result = 1};};
01968
01969         template <typename T, typename S,
01970             typename P01, typename P02, typename P03, typename P04, typename P05,
01971             typename P06, typename P07, typename P08, typename P09, typename P10,
01972             typename P11, typename P12, typename P13, typename P14, typename P15,
01973             typename P16>
01974         struct IsMemberFunctionPointerRaw<T (S::*)(
01975             P01, P02, P03, P04, P05,
01976             P06, P07, P08, P09, P10,
01977             P11, P12, P13, P14, P15,
01978             P16, ...) const volatile>
01979         {enum {result = 1};};
01980
01981         template <typename T, typename S,
01982             typename P01, typename P02, typename P03, typename P04, typename P05,
01983             typename P06, typename P07, typename P08, typename P09, typename P10,
01984             typename P11, typename P12, typename P13, typename P14, typename P15,
01985             typename P16, typename P17>
01986         struct IsMemberFunctionPointerRaw<T (S::*)(
01987             P01, P02, P03, P04, P05,
01988             P06, P07, P08, P09, P10,
01989             P11, P12, P13, P14, P15,
01990             P16, P17, ...) const volatile>
01991         {enum {result = 1};};
01992
01993         template <typename T, typename S,
01994             typename P01, typename P02, typename P03, typename P04, typename P05,
01995             typename P06, typename P07, typename P08, typename P09, typename P10,
01996             typename P11, typename P12, typename P13, typename P14, typename P15,
01997             typename P16, typename P17, typename P18>
01998         struct IsMemberFunctionPointerRaw<T (S::*)(
01999             P01, P02, P03, P04, P05,
02000             P06, P07, P08, P09, P10,
02001             P11, P12, P13, P14, P15,
02002             P16, P17, P18, ...) const volatile>
02003         {enum {result = 1};};
02004
02005         template <typename T, typename S,
02006             typename P01, typename P02, typename P03, typename P04, typename P05,
02007             typename P06, typename P07, typename P08, typename P09, typename P10,
02008             typename P11, typename P12, typename P13, typename P14, typename P15,
02009             typename P16, typename P17, typename P18, typename P19>
02010         struct IsMemberFunctionPointerRaw<T (S::*)(
02011             P01, P02, P03, P04, P05,
02012             P06, P07, P08, P09, P10,
02013             P11, P12, P13, P14, P15,
02014             P16, P17, P18, P19, ...) const volatile>
02015         {enum {result = 1};};
02016
02017         template <typename T, typename S,
02018             typename P01, typename P02, typename P03, typename P04, typename P05,
02019             typename P06, typename P07, typename P08, typename P09, typename P10,
02020             typename P11, typename P12, typename P13, typename P14, typename P15,
02021             typename P16, typename P17, typename P18, typename P19, typename P20>
02022         struct IsMemberFunctionPointerRaw<T (S::*)(
02023             P01, P02, P03, P04, P05,
02024             P06, P07, P08, P09, P10,
02025             P11, P12, P13, P14, P15,
02026             P16, P17, P18, P19, P20,
02027             ...) const volatile>
02028         {enum {result = 1};};
02029
02030       }// namespace Private
02031
02033 // class template TypeTraits
02034 //
02035 // Figures out at compile time various properties of any given type
02036 // Invocations (T is a type, TypeTraits<T>::Propertie):
02037 //
02038 // - isPointer       : returns true if T is a pointer type
02039 // - PointeeType     : returns the type to which T points if T is a pointer
02040 //                     type, NullType otherwise
02041 // - isReference     : returns true if T is a reference type
02042 // - ReferredType    : returns the type to which T refers if T is a reference
02043 //                     type, NullType otherwise
02044 // - isMemberPointer : returns true if T is a pointer to member type
02045 // - isStdUnsignedInt: returns true if T is a standard unsigned integral type
02046 // - isStdSignedInt  : returns true if T is a standard signed integral type
02047 // - isStdIntegral   : returns true if T is a standard integral type
02048 // - isStdFloat      : returns true if T is a standard floating-point type
02049 // - isStdArith      : returns true if T is a standard arithmetic type
02050 // - isStdFundamental: returns true if T is a standard fundamental type
02051 // - isUnsignedInt   : returns true if T is a unsigned integral type
02052 // - isSignedInt     : returns true if T is a signed integral type
02053 // - isIntegral      : returns true if T is a integral type
02054 // - isFloat         : returns true if T is a floating-point type
02055 // - isArith         : returns true if T is a arithmetic type
02056 // - isFundamental   : returns true if T is a fundamental type
02057 // - ParameterType   : returns the optimal type to be used as a parameter for
02058 //                     functions that take Ts
02059 // - isConst         : returns true if T is a const-qualified type
02060 // - NonConstType    : Type with removed 'const' qualifier from T, if any
02061 // - isVolatile      : returns true if T is a volatile-qualified type
02062 // - NonVolatileType : Type with removed 'volatile' qualifier from T, if any
02063 // - UnqualifiedType : Type with removed 'const' and 'volatile' qualifiers from
02064 //                     T, if any
02065 // - ConstParameterType: returns the optimal type to be used as a parameter
02066 //                       for functions that take 'const T's
02067 //
02069
02070     template <typename T>
02071     class TypeTraits
02072     {
02073     private:
02074
02075         template <class U> struct ReferenceTraits
02076         {
02077             enum { result = false };
02078             typedef U ReferredType;
02079         };
02080
02081         template <class U> struct ReferenceTraits<U&>
02082         {
02083             enum { result = true };
02084             typedef U ReferredType;
02085         };
02086
02087         template <class U> struct PointerTraits
02088         {
02089             enum { result = false };
02090             typedef NullType PointeeType;
02091         };
02092
02093         template <class U> struct PointerTraits<U*>
02094         {
02095             enum { result = true };
02096             typedef U PointeeType;
02097         };
02098
02099         template <class U> struct PointerTraits<U*&>
02100         {
02101             enum { result = true };
02102             typedef U PointeeType;
02103         };
02104
02105         template <class U> struct PToMTraits
02106         {
02107             enum { result = false };
02108         };
02109
02110         template <class U, class V> struct PToMTraits<U V::*>
02111         {
02112             enum { result = true };
02113         };
02114
02115         template <class U, class V> struct PToMTraits<U V::*&>
02116         {
02117             enum { result = true };
02118         };
02119
02120         template <class U> struct FunctionPointerTraits
02121         {
02122             enum{ result = Private::IsFunctionPointerRaw<U>::result };
02123         };
02124
02125         template <typename U> struct PToMFunctionTraits
02126         {
02127             enum{ result = Private::IsMemberFunctionPointerRaw<U>::result };
02128         };
02129
02130         template <class U> struct UnConst
02131         {
02132             typedef U Result;
02133             enum { isConst = 0 };
02134         };
02135
02136         template <class U> struct UnConst<const U>
02137         {
02138             typedef U Result;
02139             enum { isConst = 1 };
02140         };
02141
02142         template <class U> struct UnConst<const U&>
02143         {
02144             typedef U& Result;
02145             enum { isConst = 1 };
02146         };
02147
02148         template <class U> struct UnVolatile
02149         {
02150             typedef U Result;
02151             enum { isVolatile = 0 };
02152         };
02153
02154         template <class U> struct UnVolatile<volatile U>
02155         {
02156             typedef U Result;
02157             enum { isVolatile = 1 };
02158         };
02159
02160         template <class U> struct UnVolatile<volatile U&>
02161         {
02162             typedef U& Result;
02163             enum { isVolatile = 1 };
02164         };
02165
02166     public:
02167         typedef typename UnConst<T>::Result
02168             NonConstType;
02169         typedef typename UnVolatile<T>::Result
02170             NonVolatileType;
02171         typedef typename UnVolatile<typename UnConst<T>::Result>::Result
02172             UnqualifiedType;
02173         typedef typename PointerTraits<UnqualifiedType>::PointeeType
02174             PointeeType;
02175         typedef typename ReferenceTraits<T>::ReferredType
02176             ReferredType;
02177
02178         enum { isConst          = UnConst<T>::isConst };
02179         enum { isVolatile       = UnVolatile<T>::isVolatile };
02180         enum { isReference      = ReferenceTraits<UnqualifiedType>::result };
02181         enum { isFunction       = FunctionPointerTraits<typename Private::AddPointer<T>::Result >::result };
02182         enum { isFunctionPointer= FunctionPointerTraits<
02183                                         typename ReferenceTraits<UnqualifiedType>::ReferredType >::result };
02184         enum { isMemberFunctionPointer= PToMFunctionTraits<
02185                                         typename ReferenceTraits<UnqualifiedType>::ReferredType >::result };
02186         enum { isMemberPointer  = PToMTraits<
02187                                         typename ReferenceTraits<UnqualifiedType>::ReferredType >::result ||
02188                                         isMemberFunctionPointer };
02189         enum { isPointer        = PointerTraits<
02190                                         typename ReferenceTraits<UnqualifiedType>::ReferredType >::result ||
02191                                         isFunctionPointer };
02192
02193         enum { isStdUnsignedInt = TL::IndexOf<Private::StdUnsignedInts, UnqualifiedType>::value >= 0 ||
02194                                   TL::IndexOf<Private::StdUnsignedInts,
02195                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
02196         enum { isStdSignedInt   = TL::IndexOf<Private::StdSignedInts, UnqualifiedType>::value >= 0 ||
02197                                   TL::IndexOf<Private::StdSignedInts,
02198                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
02199         enum { isStdIntegral    = isStdUnsignedInt || isStdSignedInt ||
02200                                   TL::IndexOf<Private::StdOtherInts, UnqualifiedType>::value >= 0 ||
02201                                   TL::IndexOf<Private::StdOtherInts,
02202                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
02203         enum { isStdFloat       = TL::IndexOf<Private::StdFloats, UnqualifiedType>::value >= 0 ||
02204                                   TL::IndexOf<Private::StdFloats,
02205                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
02206         enum { isStdArith       = isStdIntegral || isStdFloat };
02207         enum { isStdFundamental = isStdArith || isStdFloat || Conversion<T, void>::sameType };
02208
02209         enum { isUnsignedInt    = isStdUnsignedInt || IsCustomUnsignedInt<UnqualifiedType>::value };
02210         enum { isSignedInt      = isStdSignedInt || IsCustomSignedInt<UnqualifiedType>::value };
02211         enum { isIntegral       = isStdIntegral || isUnsignedInt || isSignedInt };
02212         enum { isFloat          = isStdFloat || IsCustomFloat<UnqualifiedType>::value };
02213         enum { isArith          = isIntegral || isFloat };
02214         enum { isFundamental    = isStdFundamental || isArith };
02215
02216         typedef typename Select<isStdArith || isPointer || isMemberPointer, T,
02217                 typename Private::AddParameterType<T>::Result>::Result
02218             ParameterType;
02219     };
02220 }
02221
02222 #ifdef _MSC_VER
02223 #pragma warning( pop )
02224 #endif // _MSC_VER
02225
02226
02227 #endif // end file guardian
02228
Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Visitor.h Source File

Visitor.h

00001
00002 // The Loki Library
00003 // Copyright (c) 2001 by Andrei Alexandrescu
00004 // This code accompanies the book:
00005 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
00006 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
00007 // Permission to use, copy, modify, distribute and sell this software for any
00008 //     purpose is hereby granted without fee, provided that the above copyright
00009 //     notice appear in all copies and that both that copyright notice and this
00010 //     permission notice appear in supporting documentation.
00011 // The author or Addison-Wesley Longman make no representations about the
00012 //     suitability of this software for any purpose. It is provided "as is"
00013 //     without express or implied warranty.
00015 #ifndef LOKI_VISITOR_INC_
00016 #define LOKI_VISITOR_INC_
00017
00018 // $Id: Visitor.h 751 2006-10-17 19:50:37Z syntheticpp $
00019
00020
00022
00023 #include "Typelist.h"
00024 #include "HierarchyGenerators.h"
00025
00026 namespace Loki
00027 {
00028
00035
00036     class BaseVisitor
00037     {
00038     public:
00039         virtual ~BaseVisitor() {}
00040     };
00041
00124
00125     template <class T, typename R = void, bool ConstVisit = false>
00126     class Visitor;
00127
00128     template <class T, typename R>
00129     class Visitor<T, R, false>
00130     {
00131     public:
00132         typedef R ReturnType;
00133         typedef T ParamType;
00134         virtual ~Visitor() {}
00135         virtual ReturnType Visit(ParamType&) = 0;
00136     };
00137
00138     template <class T, typename R>
00139     class Visitor<T, R, true>
00140     {
00141     public:
00142         typedef R ReturnType;
00143         typedef const T ParamType;
00144         virtual ~Visitor() {}
00145         virtual ReturnType Visit(ParamType&) = 0;
00146     };
00147
00149 // class template Visitor (specialization)
00150 // This specialization is not present in the book. It makes it easier to define
00151 // Visitors for multiple types in a shot by using a typelist. Example:
00152 //
00153 // class SomeVisitor :
00154 //     public BaseVisitor // required
00155 //     public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
00156 // {
00157 // public:
00158 //     void Visit(RasterBitmap&); // visit a RasterBitmap
00159 //     void Visit(Paragraph &);   // visit a Paragraph
00160 // };
00162
00163     template <class Head, class Tail, typename R>
00164     class Visitor<Typelist<Head, Tail>, R, false>
00165         : public Visitor<Head, R, false>, public Visitor<Tail, R, false>
00166     {
00167     public:
00168         typedef R ReturnType;
00169        // using Visitor<Head, R>::Visit;
00170        // using Visitor<Tail, R>::Visit;
00171     };
00172
00173     template <class Head, typename R>
00174     class Visitor<Typelist<Head, NullType>, R, false> : public Visitor<Head, R, false>
00175     {
00176     public:
00177         typedef R ReturnType;
00178         using Visitor<Head, R, false>::Visit;
00179     };
00180
00181     template <class Head, class Tail, typename R>
00182     class Visitor<Typelist<Head, Tail>, R, true>
00183         : public Visitor<Head, R, true>, public Visitor<Tail, R, true>
00184     {
00185     public:
00186         typedef R ReturnType;
00187        // using Visitor<Head, R>::Visit;
00188        // using Visitor<Tail, R>::Visit;
00189     };
00190
00191     template <class Head, typename R>
00192     class Visitor<Typelist<Head, NullType>, R, true> : public Visitor<Head, R, true>
00193     {
00194     public:
00195         typedef R ReturnType;
00196         using Visitor<Head, R, true>::Visit;
00197     };
00198
00199
00201 // class template BaseVisitorImpl
00202 // Implements non-strict visitation (you can implement only part of the Visit
00203 //     functions)
00205
00206     template <class TList, typename R = void> class BaseVisitorImpl;
00207
00208     template <class Head, class Tail, typename R>
00209     class BaseVisitorImpl<Typelist<Head, Tail>, R>
00210         : public Visitor<Head, R>
00211         , public BaseVisitorImpl<Tail, R>
00212     {
00213     public:
00214        // using BaseVisitorImpl<Tail, R>::Visit;
00215
00216         virtual R Visit(Head&)
00217         { return R(); }
00218     };
00219
00220     template <class Head, typename R>
00221     class BaseVisitorImpl<Typelist<Head, NullType>, R>
00222         : public Visitor<Head, R>
00223     {
00224     public:
00225         virtual R Visit(Head&)
00226         { return R(); }
00227     };
00228
00230 // class template BaseVisitable
00232
00233 template <typename R, typename Visited>
00234 struct DefaultCatchAll
00235 {
00236     static R OnUnknownVisitor(Visited&, BaseVisitor&)
00237     { return R(); }
00238 };
00239
00241 // class template BaseVisitable
00243
00244     template
00245     <
00246         typename R = void,
00247         template <typename, class> class CatchAll = DefaultCatchAll,
00248         bool ConstVisitable = false
00249     >
00250     class BaseVisitable;
00251
00252     template<typename R,template <typename, class> class CatchAll>
00253     class BaseVisitable<R, CatchAll, false>
00254     {
00255     public:
00256         typedef R ReturnType;
00257         virtual ~BaseVisitable() {}
00258         virtual ReturnType Accept(BaseVisitor&) = 0;
00259
00260     protected: // give access only to the hierarchy
00261         template <class T>
00262         static ReturnType AcceptImpl(T& visited, BaseVisitor& guest)
00263         {
00264             // Apply the Acyclic Visitor
00265             if (Visitor<T,R>* p = dynamic_cast<Visitor<T,R>*>(&guest))
00266             {
00267                 return p->Visit(visited);
00268             }
00269             return CatchAll<R, T>::OnUnknownVisitor(visited, guest);
00270         }
00271     };
00272
00273     template<typename R,template <typename, class> class CatchAll>
00274     class BaseVisitable<R, CatchAll, true>
00275     {
00276     public:
00277         typedef R ReturnType;
00278         virtual ~BaseVisitable() {}
00279         virtual ReturnType Accept(BaseVisitor&) const = 0;
00280
00281     protected: // give access only to the hierarchy
00282         template <class T>
00283         static ReturnType AcceptImpl(const T& visited, BaseVisitor& guest)
00284         {
00285             // Apply the Acyclic Visitor
00286             if (Visitor<T,R,true>* p = dynamic_cast<Visitor<T,R,true>*>(&guest))
00287             {
00288                 return p->Visit(visited);
00289             }
00290             return CatchAll<R, T>::OnUnknownVisitor(const_cast<T&>(visited), guest);
00291         }
00292     };
00293
00294
00301
00302 #define LOKI_DEFINE_VISITABLE() \
00303     virtual ReturnType Accept(::Loki::BaseVisitor& guest) \
00304     { return AcceptImpl(*this, guest); }
00305
00312
00313 #define LOKI_DEFINE_CONST_VISITABLE() \
00314     virtual ReturnType Accept(::Loki::BaseVisitor& guest) const \
00315     { return AcceptImpl(*this, guest); }
00316
00324
00325     template <typename R, class TList>
00326     class CyclicVisitor : public Visitor<TList, R>
00327     {
00328     public:
00329         typedef R ReturnType;
00330         // using Visitor<TList, R>::Visit;
00331
00332         template <class Visited>
00333         ReturnType GenericVisit(Visited& host)
00334         {
00335             Visitor<Visited, ReturnType>& subObj = *this;
00336             return subObj.Visit(host);
00337         }
00338     };
00339
00345
00346 #define LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor) \
00347     virtual SomeVisitor::ReturnType Accept(SomeVisitor& guest) \
00348     { return guest.GenericVisit(*this); }
00349
00350 } // namespace Loki
00351
00352
00353
00354 #endif // end file guardian
00355
Generated on Sat Jul 7 15:11:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members

Loki::AbstractFactoryUnit< T > Member List

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

~AbstractFactoryUnit() Loki::AbstractFactoryUnit< T > [inline, virtual]

Generated on Sat Jul 7 15:11:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

  • Class List
  • Class Hierarchy
  • Class Members

Loki::AbstractFactory< TList, Unit > Member List

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

Create() | Loki::AbstractFactory< TList, Unit > | [inline]
ProductList typedef | Loki::AbstractFactory< TList, Unit > |

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::OpNewFactoryUnit< ConcreteProduct, Base > Member List

This is the complete list of members for Loki::OpNewFactoryUnit< ConcreteProduct, Base >, including all inherited members.

AbstractProduct typedef | Loki::OpNewFactoryUnit< ConcreteProduct, Base > |
DoCreate(Type2Type< AbstractProduct >) | Loki::OpNewFactoryUnit< ConcreteProduct, Base > | [inline]
ProductList typedef | Loki::OpNewFactoryUnit< ConcreteProduct, Base > | [protected]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::PrototypeFactoryUnit< ConcreteProduct, Base > Member List

This is the complete list of members for Loki::PrototypeFactoryUnit< ConcreteProduct, Base >, including all inherited members.

AbstractProduct typedef | Loki::PrototypeFactoryUnit< ConcreteProduct, Base > |
DoCreate(Type2Type< AbstractProduct >) | Loki::PrototypeFactoryUnit< ConcreteProduct, Base > | [inline]
GetPrototype(U *&p) | Loki::PrototypeFactoryUnit< ConcreteProduct, Base > | [inline]
ProductList typedef | Loki::PrototypeFactoryUnit< ConcreteProduct, Base > | [protected]
PrototypeFactoryUnit(AbstractProduct *p=0) | Loki::PrototypeFactoryUnit< ConcreteProduct, Base > | [inline]
SetPrototype(U *pObj) | Loki::PrototypeFactoryUnit< ConcreteProduct, Base > | [inline]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::ConcreteFactory< AbstractFact, Creator, TList > Member List

This is the complete list of members for Loki::ConcreteFactory< AbstractFact, Creator, TList >, including all inherited members.

ConcreteProductList typedef | Loki::ConcreteFactory< AbstractFact, Creator, TList >
ProductList typedef | Loki::ConcreteFactory< AbstractFact, Creator, TList >

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AssocVector< K, V, C, A > Member List

This is the complete list of members for Loki::AssocVector< K, V, C, A >, including all inherited members.

allocator_type typedef | Loki::AssocVector< K, V, C, A > |
AssocVector(const key_compare &comp=key_compare(), const A &alloc=A()) | Loki::AssocVector< K, V, C, A > | [inline, explicit]
AssocVector(InputIterator first, InputIterator last, const key_compare &comp=key_compare(), const A &alloc=A()) | Loki::AssocVector< K, V, C, A > | [inline]
AssocVectorCompare() | Loki::Private::AssocVectorCompare< V, C > | [inline, private]
AssocVectorCompare(const C &src) | Loki::Private::AssocVectorCompare< V, C > | [inline, private]
begin() | Loki::AssocVector< K, V, C, A > | [inline]
begin() const | Loki::AssocVector< K, V, C, A > | [inline]
clear() | Loki::AssocVector< K, V, C, A > | [inline]
const_iterator typedef | Loki::AssocVector< K, V, C, A > |
const_pointer typedef | Loki::AssocVector< K, V, C, A > |
const_reference typedef | Loki::AssocVector< K, V, C, A > |
const_reverse_iterator typedef | Loki::AssocVector< K, V, C, A > |
count(const key_type &k) const | Loki::AssocVector< K, V, C, A > | [inline]
difference_type typedef | Loki::AssocVector< K, V, C, A > |
empty() const | Loki::AssocVector< K, V, C, A > | [inline]
end() | Loki::AssocVector< K, V, C, A > | [inline]
end() const | Loki::AssocVector< K, V, C, A > | [inline]
equal_range(const key_type &k) | Loki::AssocVector< K, V, C, A > | [inline]
equal_range(const key_type &k) const | Loki::AssocVector< K, V, C, A > | [inline]
erase(iterator pos) | Loki::AssocVector< K, V, C, A > | [inline]
erase(const key_type &k) | Loki::AssocVector< K, V, C, A > | [inline]
erase(iterator first, iterator last) | Loki::AssocVector< K, V, C, A > | [inline]
find(const key_type &k) | Loki::AssocVector< K, V, C, A > | [inline]
find(const key_type &k) const | Loki::AssocVector< K, V, C, A > | [inline]
insert(const value_type &val) | Loki::AssocVector< K, V, C, A > | [inline]
insert(iterator pos, const value_type &val) | Loki::AssocVector< K, V, C, A > | [inline]
insert(InputIterator first, InputIterator last) | Loki::AssocVector< K, V, C, A > | [inline]
iterator typedef | Loki::AssocVector< K, V, C, A > |
key_comp() const | Loki::AssocVector< K, V, C, A > | [inline]
key_compare typedef | Loki::AssocVector< K, V, C, A > |
key_type typedef | Loki::AssocVector< K, V, C, A > |
lower_bound(const key_type &k) | Loki::AssocVector< K, V, C, A > | [inline]
lower_bound(const key_type &k) const | Loki::AssocVector< K, V, C, A > | [inline]
mapped_type typedef | Loki::AssocVector< K, V, C, A > |
max_size() | Loki::AssocVector< K, V, C, A > | [inline]
operator()(const first_argument_type &lhs, const first_argument_type &rhs) const | Loki::Private::AssocVectorCompare< V, C > | [inline, private]
operator()(const Data &lhs, const Data &rhs) const | Loki::Private::AssocVectorCompare< V, C > | [inline, private]
operator()(const Data &lhs, const first_argument_type &rhs) const | Loki::Private::AssocVectorCompare< V, C > | [inline, private]
operator()(const first_argument_type &lhs, const Data &rhs) const | Loki::Private::AssocVectorCompare< V, C > | [inline, private]
operator<(const AssocVector &rhs) const | Loki::AssocVector< K, V, C, A > | [inline]
operator=(const AssocVector &rhs) | Loki::AssocVector< K, V, C, A > | [inline]
operator[](const key_type &key) | Loki::AssocVector< K, V, C, A > | [inline]
pointer typedef | Loki::AssocVector< K, V, C, A > |
rbegin() | Loki::AssocVector< K, V, C, A > | [inline]
rbegin() const | Loki::AssocVector< K, V, C, A > | [inline]
reference typedef | Loki::AssocVector< K, V, C, A > |
rend() | Loki::AssocVector< K, V, C, A > | [inline]
rend() const | Loki::AssocVector< K, V, C, A > | [inline]
reverse_iterator typedef | Loki::AssocVector< K, V, C, A > |
size() const | Loki::AssocVector< K, V, C, A > | [inline]
size_type typedef | Loki::AssocVector< K, V, C, A > |
swap(AssocVector &other) | Loki::AssocVector< K, V, C, A > | [inline]
upper_bound(const key_type &k) | Loki::AssocVector< K, V, C, A > | [inline]
upper_bound(const key_type &k) const | Loki::AssocVector< K, V, C, A > | [inline]
value_comp() const | Loki::AssocVector< K, V, C, A > | [inline]
value_type typedef | Loki::AssocVector< K, V, C, A > |

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AssocVector< K, V, C, A >::value_compare Member List

This is the complete list of members for Loki::AssocVector< K, V, C, A >::value_compare, including all inherited members.

AssocVector class | Loki::AssocVector< K, V, C, A >::value_compare | [friend]
operator()(const value_type &lhs, const value_type &rhs) const | Loki::AssocVector< K, V, C, A >::value_compare | [inline]
value_compare(key_compare pred) | Loki::AssocVector< K, V, C, A >::value_compare | [inline, protected]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SimplePointer< AbstractProduct > Member List

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

encapsulate(AbstractProduct *pProduct) | Loki::SimplePointer< AbstractProduct > | [inline, protected]
name() | Loki::SimplePointer< AbstractProduct > | [inline, protected]
ProductReturn typedef | Loki::SimplePointer< AbstractProduct > | [protected]
release(ProductReturn &pProduct) | Loki::SimplePointer< AbstractProduct > | [inline, protected]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NeverCreate Member List

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

canCreate() | Loki::NeverCreate | [inline, protected]
name() | Loki::NeverCreate | [inline, protected]
onCreate() | Loki::NeverCreate | [inline, protected]
onDestroy() | Loki::NeverCreate | [inline, protected]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NeverCreate::Exception Member List

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

what() const Loki::NeverCreate::Exception [inline]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AlwaysCreate Member List

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

canCreate() | Loki::AlwaysCreate | [inline, protected]
name() | Loki::AlwaysCreate | [inline, protected]
onCreate() | Loki::AlwaysCreate | [inline, protected]
onDestroy() | Loki::AlwaysCreate | [inline, protected]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RateLimitedCreation Member List

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

canCreate() | Loki::RateLimitedCreation | [inline, protected]
name() | Loki::RateLimitedCreation | [inline, protected]
onCreate() | Loki::RateLimitedCreation | [inline, protected]
onDestroy() | Loki::RateLimitedCreation | [inline, protected]
RateLimitedCreation() | Loki::RateLimitedCreation | [inline, protected]
setRate(unsigned maxCreation, unsigned byTime) | Loki::RateLimitedCreation | [inline]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RateLimitedCreation::Exception Member List

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

what() const Loki::RateLimitedCreation::Exception [inline]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AmountLimitedCreation Member List

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

AmountLimitedCreation() | Loki::AmountLimitedCreation | [inline, protected]
canCreate() | Loki::AmountLimitedCreation | [inline, protected]
name() | Loki::AmountLimitedCreation | [inline, protected]
onCreate() | Loki::AmountLimitedCreation | [inline, protected]
onDestroy() | Loki::AmountLimitedCreation | [inline, protected]
setMaxCreation(unsigned maxCreation) | Loki::AmountLimitedCreation | [inline]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::EvictionException Member List

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

what() const Loki::EvictionException [inline]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::EvictionHelper< ST, DT > Member List

This is the complete list of members for Loki::EvictionHelper< ST, DT >, including all inherited members.

getLowerBound() | Loki::EvictionHelper< ST, DT > | [inline, protected]
HitMap typedef | Loki::EvictionHelper< ST, DT > | [protected]
HitMapItr typedef | Loki::EvictionHelper< ST, DT > | [protected]
m_mHitCount | Loki::EvictionHelper< ST, DT > | [protected]

Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


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.

evict() | Loki::EvictLRU< DT, ST > | [inline, protected]
getLowerBound() | Loki::EvictionHelper< ST, DT > | [inline, protected]
HitMap typedef | Loki::EvictionHelper< ST, DT > | [protected]
HitMapItr typedef | Loki::EvictionHelper< ST, DT > | [protected]
m_mHitCount | Loki::EvictionHelper< ST, DT > | [protected]
name() | Loki::EvictLRU< DT, ST > | [inline, protected]
onCreate(const DT &key) | Loki::EvictLRU< DT, ST > | [inline, protected]
onDestroy(const DT &key) | Loki::EvictLRU< DT, ST > | [inline, protected]
onFetch(const DT &) | Loki::EvictLRU< DT, ST > | [inline, protected]
onRelease(const DT &key) | Loki::EvictLRU< DT, ST > | [inline, protected]
~EvictLRU() | Loki::EvictLRU< DT, ST > | [inline, protected, virtual]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


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.

evict() | Loki::EvictAging< DT, ST > | [inline, protected]
EvictAging() | Loki::EvictAging< DT, ST > | [inline, protected]
getLowerBound() | Loki::EvictionHelper< ST, DT > | [inline, protected]
m_mHitCount | Loki::EvictionHelper< ST, DT > | [protected]
name() | Loki::EvictAging< DT, ST > | [inline, protected]
onCreate(const DT &key) | Loki::EvictAging< DT, ST > | [inline, protected]
onDestroy(const DT &key) | Loki::EvictAging< DT, ST > | [inline, protected]
onFetch(const DT &) | Loki::EvictAging< DT, ST > | [inline, protected]
onRelease(const DT &key) | Loki::EvictAging< DT, ST > | [inline, protected]
~EvictAging() | Loki::EvictAging< DT, ST > | [inline, protected, virtual]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


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.

evict() | Loki::EvictRandom< DT, ST > | [inline, protected]
name() | Loki::EvictRandom< DT, ST > | [inline, protected]
onCreate(const DT &) | Loki::EvictRandom< DT, ST > | [inline, protected]
onDestroy(const DT &key) | Loki::EvictRandom< DT, ST > | [inline, protected]
onFetch(const DT &) | Loki::EvictRandom< DT, ST > | [inline, protected]
onRelease(const DT &key) | Loki::EvictRandom< DT, ST > | [inline, protected]
~EvictRandom() | Loki::EvictRandom< DT, ST > | [inline, protected, virtual]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NoStatisticPolicy Member List

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

name() | Loki::NoStatisticPolicy | [inline, protected]
onCreate() | Loki::NoStatisticPolicy | [inline, protected]
onDebug() | Loki::NoStatisticPolicy | [inline, protected]
onDestroy() | Loki::NoStatisticPolicy | [inline, protected]
onFetch() | Loki::NoStatisticPolicy | [inline, protected]
onRelease() | Loki::NoStatisticPolicy | [inline, protected]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SimpleStatisticPolicy Member List

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

getAllocated() | Loki::SimpleStatisticPolicy | [inline]
getCreated() | Loki::SimpleStatisticPolicy | [inline]
getDestroyed() | Loki::SimpleStatisticPolicy | [inline]
getFetched() | Loki::SimpleStatisticPolicy | [inline]
getHit() | Loki::SimpleStatisticPolicy | [inline]
getMissed() | Loki::SimpleStatisticPolicy | [inline]
getOut() | Loki::SimpleStatisticPolicy | [inline]
name() | Loki::SimpleStatisticPolicy | [inline, protected]
onCreate() | Loki::SimpleStatisticPolicy | [inline, protected]
onDebug() | Loki::SimpleStatisticPolicy | [inline, protected]
onDestroy() | Loki::SimpleStatisticPolicy | [inline, protected]
onFetch() | Loki::SimpleStatisticPolicy | [inline, protected]
onRelease() | Loki::SimpleStatisticPolicy | [inline, protected]
SimpleStatisticPolicy() | Loki::SimpleStatisticPolicy | [inline, protected]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CacheException Member List

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

what() const Loki::CacheException [inline]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > Member List

This is the complete list of members for Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >, including all inherited members.

CachedFactory() | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
displayCacheType() | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
ProductReturn typedef | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > |
Register(const IdentifierType &id, ProductCreator creator) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
Register(const IdentifierType &id, const PtrObj &p, CreaFn fn) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
RegisteredIds() | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
ReleaseObject(ProductReturn &object) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
remove(AbstractProduct *const pProduct) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline, protected, virtual]
Unregister(const IdentifierType &id) | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]
~CachedFactory() | Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | [inline]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DontPropagateConst< T > Member List

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

Type typedef Loki::DontPropagateConst< T >

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::PropagateConst< T > Member List

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

Type typedef Loki::PropagateConst< T >

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


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.

OnUnknownType(IdentifierType) Loki::DefaultFactoryError< IdentifierType, AbstractProduct > [inline, static]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception Member List

This is the complete list of members for Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception, including all inherited members.

what() const Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception [inline]

Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImplBase Member List

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

Parm1 typedef | Loki::FactoryImplBase
Parm10 typedef | Loki::FactoryImplBase
Parm11 typedef | Loki::FactoryImplBase
Parm12 typedef | Loki::FactoryImplBase
Parm13 typedef | Loki::FactoryImplBase
Parm14 typedef | Loki::FactoryImplBase
Parm15 typedef | Loki::FactoryImplBase
Parm2 typedef | Loki::FactoryImplBase
Parm3 typedef | Loki::FactoryImplBase
Parm4 typedef | Loki::FactoryImplBase
Parm5 typedef | Loki::FactoryImplBase
Parm6 typedef | Loki::FactoryImplBase
Parm7 typedef | Loki::FactoryImplBase
Parm8 typedef | Loki::FactoryImplBase
Parm9 typedef | Loki::FactoryImplBase

Generated on Sat Jul 7 15:11:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, NullType > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, NullType >, including all inherited members.

Parm1 typedef | Loki::FactoryImplBase |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImplBase |
Parm3 typedef | Loki::FactoryImplBase |
Parm4 typedef | Loki::FactoryImplBase |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, NullType > | [inline, virtual]

Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImplBase |
Parm3 typedef | Loki::FactoryImplBase |
Parm4 typedef | Loki::FactoryImplBase |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > |
Parm3 typedef | Loki::FactoryImplBase |
Parm4 typedef | Loki::FactoryImplBase |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > |
Parm4 typedef | Loki::FactoryImplBase |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Parm9 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm10 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Parm9 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm10 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm11 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Parm9 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm10 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm11 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm12 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Parm9 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm10 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm11 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm12 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm13 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Parm9 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm10 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm11 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm12 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm13 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm14 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Parm9 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > >, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm10 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm11 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm12 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm13 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm14 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm15 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm2 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm3 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm4 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm5 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm6 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm7 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm8 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Parm9 typedef | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
~FactoryImpl() | Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > | [inline, virtual]

Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


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.

CreateObject(const IdentifierType &id) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
CreateObject(const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
Factory() | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
Register(const IdentifierType &id, ProductCreator creator) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
Register(const IdentifierType &id, const PtrObj &p, CreaFn fn) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
RegisteredIds() | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
Unregister(const IdentifierType &id) | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]
~Factory() | Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > | [inline]

Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


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.

CreateObject(const AbstractProduct *model) | Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > | [inline]
Register(const TypeInfo &ti, ProductCreator creator) | Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > | [inline]
Unregister(const TypeInfo &id) | Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > | [inline]

Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R()> Member List

This is the complete list of members for Loki::Function< R()>, including all inherited members.

FBase typedef | Loki::Function< R()> |
Function() | Loki::Function< R()> | [inline]
Function(const Function &func) | Loki::Function< R()> | [inline]
Function(Function< R2()> func) | Loki::Function< R()> | [inline]
Function(const int i) | Loki::Function< R()> | [inline]
Function(Func func) | Loki::Function< R()> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R()> | [inline]
Functor() | Loki::Functor< R > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R > | [inline]
Functor(Fun fun) | Loki::Functor< R > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R > | [inline]
Impl typedef | Loki::Functor< R > |
operator unspecified_bool_type() const | Loki::Functor< R > | [inline]
operator()() const | Loki::Functor< R > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R > | [inline]
Parm1 typedef | Loki::Functor< R > |
Parm10 typedef | Loki::Functor< R > |
Parm11 typedef | Loki::Functor< R > |
Parm12 typedef | Loki::Functor< R > |
Parm13 typedef | Loki::Functor< R > |
Parm14 typedef | Loki::Functor< R > |
Parm15 typedef | Loki::Functor< R > |
Parm2 typedef | Loki::Functor< R > |
Parm3 typedef | Loki::Functor< R > |
Parm4 typedef | Loki::Functor< R > |
Parm5 typedef | Loki::Functor< R > |
Parm6 typedef | Loki::Functor< R > |
Parm7 typedef | Loki::Functor< R > |
Parm8 typedef | Loki::Functor< R > |
Parm9 typedef | Loki::Functor< R > |
ParmList typedef | Loki::Functor< R > |
ResultType typedef | Loki::Functor< R > |
unspecified_bool_type typedef | Loki::Functor< R > |

Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function<> Member List

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

FBase typedef | Loki::Function<> |
Function(Function< R2()> func) | Loki::Function<> | [inline]
Function() | Loki::Function<> | [inline]
Function(const Function &func) | Loki::Function<> | [inline]
Function(const int i) | Loki::Function<> | [inline]
Function(Func func) | Loki::Function<> | [inline]
Function(const Host &host, const Func &func) | Loki::Function<> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01)> Member List

This is the complete list of members for Loki::Function< R(P01)>, including all inherited members.

FBase typedef | Loki::Function< R(P01)> |
Function(Function< R2(Q01)> func) | Loki::Function< R(P01)> | [inline]
Function() | Loki::Function< R(P01)> | [inline]
Function(const Function &func) | Loki::Function< R(P01)> | [inline]
Function(const int i) | Loki::Function< R(P01)> | [inline]
Function(Func func) | Loki::Function< R(P01)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02)> Member List

This is the complete list of members for Loki::Function< R(P01, P02)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02)> |
Function(Function< R2(Q01, Q02)> func) | Loki::Function< R(P01, P02)> | [inline]
Function() | Loki::Function< R(P01, P02)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03)> |
Function(Function< R2(Q01, Q02, Q03)> func) | Loki::Function< R(P01, P02, P03)> | [inline]
Function() | Loki::Function< R(P01, P02, P03)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04)> |
Function(Function< R2(Q01, Q02, Q03, Q04)> func) | Loki::Function< R(P01, P02, P03, P04)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05)> func) | Loki::Function< R(P01, P02, P03, P04, P05)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:53 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:53 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:53 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13, Q14)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:54 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Member List

This is the complete list of members for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>, including all inherited members.

FBase typedef | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> |
Function(Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13, Q14, Q15)> func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> | [inline]
Function() | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> | [inline]
Function(const Function &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> | [inline]
Function(const int i) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> | [inline]
Function(Func func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> | [inline]
Function(const Host &host, const Func &func) | Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> | [inline]
Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:11:54 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, NullType, ThreadingModel > Member List

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

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm3 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, NullType, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:54 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm3 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:55 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > |
Parm3 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:55 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:55 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:56 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:56 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:57 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:57 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:57 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Parm9 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:58 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm10 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Parm9 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:58 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm10 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm11 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Parm9 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:59 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm10 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm11 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm12 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Parm9 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:59 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm10 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm11 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm12 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm13 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Parm9 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:11:59 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm10 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm11 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm12 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm13 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm14 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Parm9 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm10 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm11 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm12 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm13 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm14 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm15 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm7 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm8 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Parm9 typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorHandler< ParentFunctor, Fun > Member List

This is the complete list of members for Loki::FunctorHandler< ParentFunctor, Fun >, including all inherited members.

DoClone() const | Loki::FunctorHandler< ParentFunctor, Fun > | [inline, virtual]
FunctorHandler(const Fun &fun) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()() | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) | Loki::FunctorHandler< ParentFunctor, Fun > | [inline]
Parm1 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm10 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm11 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm12 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm13 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm14 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm15 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm2 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm3 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm4 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm5 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm6 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm7 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm8 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
Parm9 typedef | Loki::FunctorHandler< ParentFunctor, Fun > |
ResultType typedef | Loki::FunctorHandler< ParentFunctor, Fun > |

Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > Member List

This is the complete list of members for Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >, including all inherited members.

DoClone() const | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline, virtual]
MemFunHandler(const PointerToObj &pObj, PointerToMemFn pMemFn) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()() | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | [inline]
Parm1 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm10 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm11 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm12 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm13 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm14 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm15 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm2 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm3 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm4 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm5 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm6 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm7 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm8 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Parm9 typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
ResultType typedef | Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |

Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


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.

Functor() | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(std::auto_ptr< Impl > spImpl) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(Fun fun) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Functor(const PtrObj &p, MemFn memFn) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Impl typedef | Loki::Functor< R, TList, ThreadingModel > |
operator unspecified_bool_type() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()() const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const | Loki::Functor< R, TList, ThreadingModel > | [inline]
operator=(const Functor &rhs) | Loki::Functor< R, TList, ThreadingModel > | [inline]
Parm1 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm10 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm11 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm12 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm13 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm14 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm15 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm2 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm3 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm4 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm5 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm6 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm7 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm8 typedef | Loki::Functor< R, TList, ThreadingModel > |
Parm9 typedef | Loki::Functor< R, TList, ThreadingModel > |
ParmList typedef | Loki::Functor< R, TList, ThreadingModel > |
ResultType typedef | Loki::Functor< R, TList, ThreadingModel > |
unspecified_bool_type typedef | Loki::Functor< R, TList, ThreadingModel > |

Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::BinderFirst< OriginalFunctor > Member List

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

BinderFirst(const OriginalFunctor &fun, BoundType bound) | Loki::BinderFirst< OriginalFunctor > | [inline]
DoClone() const | Loki::BinderFirst< OriginalFunctor > | [inline, virtual]
operator()() | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) | Loki::BinderFirst< OriginalFunctor > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) | Loki::BinderFirst< OriginalFunctor > | [inline]

Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


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.

Chainer(const Fun1 &fun1, const Fun2 &fun2) | Loki::Chainer< Fun1, Fun2 > | [inline]
DoClone() const | Loki::Chainer< Fun1, Fun2 > | [inline, virtual]
operator()() | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) | Loki::Chainer< Fun1, Fun2 > | [inline]
operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) | Loki::Chainer< Fun1, Fun2 > | [inline]
Parm1 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm10 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm11 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm12 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm13 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm14 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm15 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm2 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm3 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm4 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm5 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm6 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm7 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm8 typedef | Loki::Chainer< Fun1, Fun2 > |
Parm9 typedef | Loki::Chainer< Fun1, Fun2 > |
ResultType typedef | Loki::Chainer< Fun1, Fun2 > |

Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > Member List

This is the complete list of members for Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >, including all inherited members.

LeftBase typedef | Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >
RightBase typedef | Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >
TList typedef | Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >

Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T > Member List

This is the complete list of members for Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T >, including all inherited members.

Result typedef Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T >

Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::GenScatterHierarchy< AtomicType, Unit > Member List

This is the complete list of members for Loki::GenScatterHierarchy< AtomicType, Unit >, including all inherited members.

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TupleUnit< T > Member List

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

operator const T &() const | Loki::TupleUnit< T > | [inline]
operator T &() | Loki::TupleUnit< T > | [inline]
value_ | Loki::TupleUnit< T > |

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FieldHelper< H, 0 > Member List

This is the complete list of members for Loki::FieldHelper< H, 0 >, including all inherited members.

ConstLeftBase typedef | Loki::FieldHelper< H, 0 > |
Do(H &obj) | Loki::FieldHelper< H, 0 > | [inline, static]
ElementType typedef | Loki::FieldHelper< H, 0 > |
LeftBase typedef | Loki::FieldHelper< H, 0 > |
ResultType typedef | Loki::FieldHelper< H, 0 > |
UnitType typedef | Loki::FieldHelper< H, 0 > |
UnqualifiedResultType typedef | Loki::FieldHelper< H, 0 > |

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FieldHelper< H, i > Member List

This is the complete list of members for Loki::FieldHelper< H, i >, including all inherited members.

ConstRightBase typedef | Loki::FieldHelper< H, i > |
Do(H &obj) | Loki::FieldHelper< H, i > | [inline, static]
ElementType typedef | Loki::FieldHelper< H, i > |
ResultType typedef | Loki::FieldHelper< H, i > |
RightBase typedef | Loki::FieldHelper< H, i > |
UnitType typedef | Loki::FieldHelper< H, i > |
UnqualifiedResultType typedef | Loki::FieldHelper< H, i > |

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


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.

count | Loki::Key< Factory, IdentifierType > |
id | Loki::Key< Factory, IdentifierType > |
Key() | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12, Parm13 &p13) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14) | Loki::Key< Factory, IdentifierType > | [inline]
Key(const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14, Parm15 &p15) | Loki::Key< Factory, IdentifierType > | [inline]
p1 | Loki::Key< Factory, IdentifierType > |
p10 | Loki::Key< Factory, IdentifierType > |
p11 | Loki::Key< Factory, IdentifierType > |
p12 | Loki::Key< Factory, IdentifierType > |
p13 | Loki::Key< Factory, IdentifierType > |
p14 | Loki::Key< Factory, IdentifierType > |
p15 | Loki::Key< Factory, IdentifierType > |
p2 | Loki::Key< Factory, IdentifierType > |
p3 | Loki::Key< Factory, IdentifierType > |
p4 | Loki::Key< Factory, IdentifierType > |
p5 | Loki::Key< Factory, IdentifierType > |
p6 | Loki::Key< Factory, IdentifierType > |
p7 | Loki::Key< Factory, IdentifierType > |
p8 | Loki::Key< Factory, IdentifierType > |
p9 | Loki::Key< Factory, IdentifierType > |

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


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.

ConstOrNotType typedef | Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > |
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]
Pair typedef | Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > |
~LockingPtr() | Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > | [inline]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TypeInfo Member List

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

before(const TypeInfo &rhs) const | Loki::TypeInfo | [inline]
Get() const | Loki::TypeInfo | [inline]
name() const | Loki::TypeInfo | [inline]
TypeInfo() | Loki::TypeInfo | [inline]
TypeInfo(const std::type_info &) | Loki::TypeInfo | [inline]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType > Member List

This is the complete list of members for Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType >, including all inherited members.

Go(BaseLhs &lhs, BaseRhs &rhs, Executor exec) Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType > [inline, static]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > Member List

This is the complete list of members for Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType >, including all inherited members.

Add(CallbackType fun) | Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > | [inline]
Go(BaseLhs &lhs, BaseRhs &rhs) | Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > |
Remove() | Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > | [inline]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::StaticCaster< To, From > Member List

This is the complete list of members for Loki::StaticCaster< To, From >, including all inherited members.

Cast(From &obj) Loki::StaticCaster< To, From > [inline, static]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DynamicCaster< To, From > Member List

This is the complete list of members for Loki::DynamicCaster< To, From >, including all inherited members.

Cast(From &obj) Loki::DynamicCaster< To, From > [inline, static]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > Member List

This is the complete list of members for Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >, including all inherited members.

Add(ResultType(*pFun)(BaseLhs &, BaseRhs &)) | Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]
Add() | Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]
Add(bool=true) | Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]
Go(BaseLhs &lhs, BaseRhs &rhs) | Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]
Remove() | Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > Member List

This is the complete list of members for Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >, including all inherited members.

Add(const Fun &fun) | Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]
Add(const Fun &fun) | Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]
Go(BaseLhs &lhs, BaseRhs &rhs) | Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]
Remove() | Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > | [inline]

Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::OrderedStatic< L, T, P1(*)() > Member List

This is the complete list of members for Loki::OrderedStatic< L, T, P1(*)() >, including all inherited members.

createObject() | Loki::OrderedStatic< L, T, P1(*)() > | [inline, virtual]
Func typedef | Loki::OrderedStatic< L, T, P1(*)() > |
operator *() | Loki::Private::OrderedStaticBase< T > | [inline]
operator->() | Loki::Private::OrderedStaticBase< T > | [inline]
OrderedStatic(Func p) | Loki::OrderedStatic< L, T, P1(*)() > | [inline]
OrderedStaticBase(unsigned int longevity) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected]
SetLongevity(T *ptr) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
~OrderedStaticBase() | Loki::Private::OrderedStaticBase< T > | [inline, protected, virtual]
~OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected, virtual]

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::ConstPropPtr< T > Member List

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

ConstPropPtr(T *p) | Loki::ConstPropPtr< T > | [inline, explicit]
operator *() | Loki::ConstPropPtr< T > | [inline]
operator *() const | Loki::ConstPropPtr< T > | [inline]
operator->() | Loki::ConstPropPtr< T > | [inline]
operator->() const | Loki::ConstPropPtr< T > | [inline]
~ConstPropPtr() | Loki::ConstPropPtr< T > | [inline]

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


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.

Impl typedef | Loki::Pimpl< T, Pointer > |
operator *() | Loki::Pimpl< T, Pointer > | [inline]
operator *() const | Loki::Pimpl< T, Pointer > | [inline]
operator->() | Loki::Pimpl< T, Pointer > | [inline]
operator->() const | Loki::Pimpl< T, Pointer > | [inline]
Pimpl() | Loki::Pimpl< T, Pointer > | [inline]
wrapped() | Loki::Pimpl< T, Pointer > | [inline]
wrapped() const | Loki::Pimpl< T, Pointer > | [inline]
~Pimpl() | Loki::Pimpl< T, Pointer > | [inline]

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::PimplOwner< T, Pointer > Member List

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

d Loki::PimplOwner< T, Pointer >

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::PimplOf< T, Ptr > Member List

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

Impl typedef | Loki::PimplOf< T, Ptr >
Owner typedef | Loki::PimplOf< T, Ptr >
Type typedef | Loki::PimplOf< T, Ptr >

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RimplOf< T, UsedPimpl > Member List

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

Type typedef Loki::RimplOf< T, UsedPimpl >

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RimplOf< T, UsedPimpl >::Owner Member List

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

d | Loki::RimplOf< T, UsedPimpl >::Owner |
Owner() | Loki::RimplOf< T, UsedPimpl >::Owner | [inline]

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RefToValue< T > Member List

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

operator T &() const | Loki::RefToValue< T > | [inline]
RefToValue(T &ref) | Loki::RefToValue< T > | [inline]
RefToValue(const RefToValue &rhs) | Loki::RefToValue< T > | [inline]

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::PrintfState< Device, Char > Member List

This is the complete list of members for Loki::PrintfState< Device, Char >, including all inherited members.

operator int() const | Loki::PrintfState< Device, Char > | [inline]
operator()(bool par) | Loki::PrintfState< Device, Char > | [inline]
operator()(char par) | Loki::PrintfState< Device, Char > | [inline]
operator()(signed char par) | Loki::PrintfState< Device, Char > | [inline]
operator()(unsigned char par) | Loki::PrintfState< Device, Char > | [inline]
operator()(signed short par) | Loki::PrintfState< Device, Char > | [inline]
operator()(unsigned short par) | Loki::PrintfState< Device, Char > | [inline]
operator()(signed int par) | Loki::PrintfState< Device, Char > | [inline]
operator()(signed long par) | Loki::PrintfState< Device, Char > | [inline]
operator()(unsigned int par) | Loki::PrintfState< Device, Char > | [inline]
operator()(unsigned long i) | Loki::PrintfState< Device, Char > | [inline]
operator()(void *n) | Loki::PrintfState< Device, Char > | [inline]
operator()(double n) | Loki::PrintfState< Device, Char > | [inline]
operator()(long double n) | Loki::PrintfState< Device, Char > | [inline]
operator()(int *pi) | Loki::PrintfState< Device, Char > | [inline]
operator()(short *pi) | Loki::PrintfState< Device, Char > | [inline]
operator()(long *pi) | Loki::PrintfState< Device, Char > | [inline]
operator()(const std::string &stdstr) | Loki::PrintfState< Device, Char > | [inline]
operator()(const char *const s) | Loki::PrintfState< Device, Char > | [inline]
operator()(const void *const p) | Loki::PrintfState< Device, Char > | [inline]
PrintfState(Device dev, const Char *format) | Loki::PrintfState< Device, Char > | [inline]
~PrintfState() | Loki::PrintfState< Device, Char > | [inline]

Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::ScopeGuardImplBase Member List

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

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::ScopeGuardImpl0< F > Member List

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

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ScopeGuardImpl0< F > | [inline]
fun_ | Loki::ScopeGuardImpl0< F > | [protected]
MakeGuard(F fun) | Loki::ScopeGuardImpl0< F > | [inline, static]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImpl0(F fun) | Loki::ScopeGuardImpl0< F > | [inline, protected]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ScopeGuardImpl0() | Loki::ScopeGuardImpl0< F > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ScopeGuardImpl1< F, P1 > | [inline]
fun_ | Loki::ScopeGuardImpl1< F, P1 > | [protected]
MakeGuard(F fun, P1 p1) | Loki::ScopeGuardImpl1< F, P1 > | [inline, static]
p1_ | Loki::ScopeGuardImpl1< F, P1 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImpl1(F fun, P1 p1) | Loki::ScopeGuardImpl1< F, P1 > | [inline, protected]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ScopeGuardImpl1() | Loki::ScopeGuardImpl1< F, P1 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ScopeGuardImpl2< F, P1, P2 > | [inline]
fun_ | Loki::ScopeGuardImpl2< F, P1, P2 > | [protected]
MakeGuard(F fun, P1 p1, P2 p2) | Loki::ScopeGuardImpl2< F, P1, P2 > | [inline, static]
p1_ | Loki::ScopeGuardImpl2< F, P1, P2 > | [protected]
p2_ | Loki::ScopeGuardImpl2< F, P1, P2 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImpl2(F fun, P1 p1, P2 p2) | Loki::ScopeGuardImpl2< F, P1, P2 > | [inline, protected]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ScopeGuardImpl2() | Loki::ScopeGuardImpl2< F, P1, P2 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [inline]
fun_ | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [protected]
MakeGuard(F fun, P1 p1, P2 p2, P3 p3) | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [inline, static]
p1_ | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [protected]
p2_ | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [protected]
p3_ | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [inline, protected]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ScopeGuardImpl3() | Loki::ScopeGuardImpl3< F, P1, P2, P3 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [inline]
fun_ | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [protected]
MakeGuard(F fun, P1 p1, P2 p2, P3 p3, P4 p4) | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [inline, static]
p1_ | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [protected]
p2_ | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [protected]
p3_ | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [protected]
p4_ | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImpl4(F fun, P1 p1, P2 p2, P3 p3, P4 p4) | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [inline, protected]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ScopeGuardImpl4() | Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [inline]
fun_ | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [protected]
MakeGuard(F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [inline, static]
p1_ | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [protected]
p2_ | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [protected]
p3_ | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [protected]
p4_ | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [protected]
p5_ | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImpl5(F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [inline, protected]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ScopeGuardImpl5() | Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ObjScopeGuardImpl0< Obj, MemFun > | [inline]
MakeObjGuard(Obj &obj, MemFun memFun) | Loki::ObjScopeGuardImpl0< Obj, MemFun > | [inline, static]
memFun_ | Loki::ObjScopeGuardImpl0< Obj, MemFun > | [protected]
obj_ | Loki::ObjScopeGuardImpl0< Obj, MemFun > | [protected]
ObjScopeGuardImpl0(Obj &obj, MemFun memFun) | Loki::ObjScopeGuardImpl0< Obj, MemFun > | [inline, protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ObjScopeGuardImpl0() | Loki::ObjScopeGuardImpl0< Obj, MemFun > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | [inline]
MakeObjGuard(Obj &obj, MemFun memFun, P1 p1) | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | [inline, static]
memFun_ | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | [protected]
obj_ | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | [protected]
ObjScopeGuardImpl1(Obj &obj, MemFun memFun, P1 p1) | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | [inline, protected]
p1_ | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ObjScopeGuardImpl1() | Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [inline]
MakeObjGuard(Obj &obj, MemFun memFun, P1 p1, P2 p2) | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [inline, static]
memFun_ | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [protected]
obj_ | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [protected]
ObjScopeGuardImpl2(Obj &obj, MemFun memFun, P1 p1, P2 p2) | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [inline, protected]
p1_ | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [protected]
p2_ | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ObjScopeGuardImpl2() | Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


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.

Dismiss() const | Loki::ScopeGuardImplBase | [inline]
dismissed_ | Loki::ScopeGuardImplBase | [mutable, protected]
Execute() | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [inline]
MakeObjGuard(Obj &obj, MemFun memFun, P1 p1, P2 p2, P3 p3) | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [inline, static]
memFun_ | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [protected]
obj_ | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [protected]
ObjScopeGuardImpl3(Obj &obj, MemFun memFun, P1 p1, P2 p2, P3 p3) | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [inline, protected]
p1_ | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [protected]
p2_ | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [protected]
p3_ | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [protected]
SafeExecute(J &j) | Loki::ScopeGuardImplBase | [inline, protected, static]
ScopeGuardImplBase(const ScopeGuardImplBase &other) | Loki::ScopeGuardImplBase | [inline, protected]
ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline]
~ObjScopeGuardImpl3() | Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | [inline]
~ScopeGuardImplBase() | Loki::ScopeGuardImplBase | [inline, protected]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > Member List

This is the complete list of members for Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 >, including all inherited members.

Type typedef Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 >

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Seq<> Member List

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

Type typedef Loki::Seq<>

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CreateUsingNew< T > Member List

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

Create() | Loki::CreateUsingNew< T > | [inline, static]
Destroy(T *p) | Loki::CreateUsingNew< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CreateUsing< Alloc >::Allocator< T > Member List

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

allocator | Loki::CreateUsing< Alloc >::Allocator< T > | [static]
Create() | Loki::CreateUsing< Alloc >::Allocator< T > | [inline, static]
Destroy(T *p) | Loki::CreateUsing< Alloc >::Allocator< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CreateUsingMalloc< T > Member List

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

Create() | Loki::CreateUsingMalloc< T > | [inline, static]
Destroy(T *p) | Loki::CreateUsingMalloc< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CreateStatic< T > Member List

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

Create() | Loki::CreateStatic< T > | [inline, static]
Destroy(T *p) | Loki::CreateStatic< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CreateStatic< T >::MaxAlign Member List

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

double_ | Loki::CreateStatic< T >::MaxAlign
float_ | Loki::CreateStatic< T >::MaxAlign
int_ | Loki::CreateStatic< T >::MaxAlign
longDouble_ | Loki::CreateStatic< T >::MaxAlign
longInt_ | Loki::CreateStatic< T >::MaxAlign
pMember_ | Loki::CreateStatic< T >::MaxAlign
shortInt_ | Loki::CreateStatic< T >::MaxAlign
t_ | Loki::CreateStatic< T >::MaxAlign

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DefaultLifetime< T > Member List

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

OnDeadReference() | Loki::DefaultLifetime< T > | [inline, static]
ScheduleDestruction(T *, atexit_pfn_t pFun) | Loki::DefaultLifetime< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::PhoenixSingleton< T > Member List

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

OnDeadReference() | Loki::PhoenixSingleton< T > | [inline, static]
ScheduleDestruction(T *, atexit_pfn_t pFun) | Loki::PhoenixSingleton< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DeletableSingleton< T > Member List

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

atexitCallback() | Loki::DeletableSingleton< T > | [inline, protected, static]
deleter | Loki::DeletableSingleton< T > | [protected, static]
GracefulDelete() | Loki::DeletableSingleton< T > | [inline, static]
isDead | Loki::DeletableSingleton< T > | [protected, static]
needCallback | Loki::DeletableSingleton< T > | [protected, static]
OnDeadReference() | Loki::DeletableSingleton< T > | [inline, static]
ScheduleDestruction(T *, atexit_pfn_t pFun) | Loki::DeletableSingleton< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SingletonWithLongevity< T > Member List

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

OnDeadReference() | Loki::SingletonWithLongevity< T > | [inline, static]
ScheduleDestruction(T *pObj, atexit_pfn_t pFun) | Loki::SingletonWithLongevity< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NoDestroy< T > Member List

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

OnDeadReference() | Loki::NoDestroy< T > | [inline, static]
ScheduleDestruction(T *, atexit_pfn_t) | Loki::NoDestroy< T > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

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

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

OnDeadReference() | Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F > | [inline, static]
ScheduleDestruction(F *, atexit_pfn_t pFun) | Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

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

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

OnDeadReference() | Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master > | [inline, static]
ScheduleDestruction(Master *pObj, atexit_pfn_t pFun) | Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master > | [inline, static]

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


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 typedef | Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > |

Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


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 Sat Jul 7 15:12:09 2007 for Loki by doxygen 1.5.1-p1


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 > | [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 > | [static]
MyAllocator typedef | Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > |
MyAllocatorSingleton typedef | Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > |
MyThreadingModel typedef | Loki::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 Sat Jul 7 15:12:10 2007 for Loki by doxygen 1.5.1-p1


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 typedef | Loki::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]
operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]

Generated on Sat Jul 7 15:12:10 2007 for Loki by doxygen 1.5.1-p1


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 typedef | Loki::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]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObject(void) | Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallObject() | Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]

Generated on Sat Jul 7 15:12:13 2007 for Loki by doxygen 1.5.1-p1


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 typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::HeapStorage< T > Member List

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

Default() | Loki::HeapStorage< T > | [inline, protected, static]
Destroy() | Loki::HeapStorage< T > | [inline, protected]
HeapStorage() | Loki::HeapStorage< T > | [inline]
HeapStorage(const HeapStorage &) | Loki::HeapStorage< T > | [inline]
HeapStorage(const HeapStorage< U > &) | Loki::HeapStorage< T > | [inline]
HeapStorage(const StoredType &p) | Loki::HeapStorage< T > | [inline]
InitPointerType typedef | Loki::HeapStorage< T > |
operator *() const | Loki::HeapStorage< T > | [inline]
operator->() const | Loki::HeapStorage< T > | [inline]
PointerType typedef | Loki::HeapStorage< T > |
ReferenceType typedef | Loki::HeapStorage< T > |
StoredType typedef | Loki::HeapStorage< T > |
Swap(HeapStorage &rhs) | Loki::HeapStorage< T > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DefaultSPStorage< T > Member List

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

Default() | Loki::DefaultSPStorage< T > | [inline, protected, static]
DefaultSPStorage() | Loki::DefaultSPStorage< T > | [inline]
DefaultSPStorage(const DefaultSPStorage &) | Loki::DefaultSPStorage< T > | [inline]
DefaultSPStorage(const DefaultSPStorage< U > &) | Loki::DefaultSPStorage< T > | [inline]
DefaultSPStorage(const StoredType &p) | Loki::DefaultSPStorage< T > | [inline]
Destroy() | Loki::DefaultSPStorage< T > | [inline, protected]
InitPointerType typedef | Loki::DefaultSPStorage< T > |
operator *() const | Loki::DefaultSPStorage< T > | [inline]
operator->() const | Loki::DefaultSPStorage< T > | [inline]
PointerType typedef | Loki::DefaultSPStorage< T > |
ReferenceType typedef | Loki::DefaultSPStorage< T > |
StoredType typedef | Loki::DefaultSPStorage< T > |
Swap(DefaultSPStorage &rhs) | Loki::DefaultSPStorage< T > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Locker< T > Member List

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

Locker(const T *p) | Loki::Locker< T > | [inline]
operator T *() | Loki::Locker< T > | [inline]
operator->() | Loki::Locker< T > | [inline]
~Locker(void) | Loki::Locker< T > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::LockedStorage< T > Member List

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

Default() | Loki::LockedStorage< T > | [inline, protected, static]
Destroy() | Loki::LockedStorage< T > | [inline, protected]
InitPointerType typedef | Loki::LockedStorage< T > |
LockedStorage() | Loki::LockedStorage< T > | [inline]
LockedStorage(const LockedStorage &) | Loki::LockedStorage< T > | [inline]
LockedStorage(const StoredType &p) | Loki::LockedStorage< T > | [inline]
operator->() | Loki::LockedStorage< T > | [inline]
PointerType typedef | Loki::LockedStorage< T > |
ReferenceType typedef | Loki::LockedStorage< T > |
StoredType typedef | Loki::LockedStorage< T > |
Swap(LockedStorage &rhs) | Loki::LockedStorage< T > | [inline]
~LockedStorage(void) | Loki::LockedStorage< T > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::ArrayStorage< T > Member List

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

ArrayStorage() | Loki::ArrayStorage< T > | [inline]
ArrayStorage(const ArrayStorage &) | Loki::ArrayStorage< T > | [inline]
ArrayStorage(const ArrayStorage< U > &) | Loki::ArrayStorage< T > | [inline]
ArrayStorage(const StoredType &p) | Loki::ArrayStorage< T > | [inline]
Default() | Loki::ArrayStorage< T > | [inline, protected, static]
Destroy() | Loki::ArrayStorage< T > | [inline, protected]
InitPointerType typedef | Loki::ArrayStorage< T > |
operator *() const | Loki::ArrayStorage< T > | [inline]
operator->() const | Loki::ArrayStorage< T > | [inline]
PointerType typedef | Loki::ArrayStorage< T > |
ReferenceType typedef | Loki::ArrayStorage< T > |
StoredType typedef | Loki::ArrayStorage< T > |
Swap(ArrayStorage &rhs) | Loki::ArrayStorage< T > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RefCounted< P > Member List

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

Clone(const P &val) | Loki::RefCounted< P > | [inline]
RefCounted() | Loki::RefCounted< P > | [inline]
RefCounted(const RefCounted &rhs) | Loki::RefCounted< P > | [inline]
RefCounted(const RefCounted< P1 > &rhs) | Loki::RefCounted< P > | [inline]
Release(const P &) | Loki::RefCounted< P > | [inline]
Swap(RefCounted &rhs) | Loki::RefCounted< P > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > Member List

This is the complete list of members for Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >, including all inherited members.

Clone(const P &val) | Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > | [inline]
RefCountedMT() | Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > | [inline]
RefCountedMT(const RefCountedMT &rhs) | Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > | [inline]
RefCountedMT(const RefCountedMT< P1 > &rhs) | Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > | [inline]
Release(const P &) | Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > | [inline]
Swap(RefCountedMT &rhs) | Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::COMRefCounted< P > Member List

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

Clone(const P &val) | Loki::COMRefCounted< P > | [inline, static]
COMRefCounted() | Loki::COMRefCounted< P > | [inline]
COMRefCounted(const COMRefCounted< U > &) | Loki::COMRefCounted< P > | [inline]
Release(const P &val) | Loki::COMRefCounted< P > | [inline, static]
Swap(COMRefCounted &) | Loki::COMRefCounted< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DeepCopy< P > Member List

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

Clone(const P &val) | Loki::DeepCopy< P > | [inline, static]
DeepCopy() | Loki::DeepCopy< P > | [inline]
DeepCopy(const DeepCopy< P1 > &) | Loki::DeepCopy< P > | [inline]
Release(const P &) | Loki::DeepCopy< P > | [inline, static]
Swap(DeepCopy &) | Loki::DeepCopy< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RefLinked< P > Member List

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

Clone(const P &val) | Loki::RefLinked< P > | [inline, static]
Merge(RefLinked< P1 > &rhs) | Loki::RefLinked< P > | [inline]
Loki::Private::RefLinkedBase::Merge(RefLinkedBase &rhs) | Loki::Private::RefLinkedBase |
RefLinked() | Loki::RefLinked< P > | [inline]
RefLinked(const RefLinked< P1 > &rhs) | Loki::RefLinked< P > | [inline]
RefLinkedBase() | Loki::Private::RefLinkedBase | [inline]
RefLinkedBase(const RefLinkedBase &rhs) | Loki::Private::RefLinkedBase |
Release(const P &) | Loki::RefLinked< P > | [inline]
Loki::Private::RefLinkedBase::Release() | Loki::Private::RefLinkedBase |
Swap(RefLinkedBase &rhs) | Loki::Private::RefLinkedBase |

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DestructiveCopy< P > Member List

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

Clone(P1 &val) | Loki::DestructiveCopy< P > | [inline, static]
DestructiveCopy() | Loki::DestructiveCopy< P > | [inline]
DestructiveCopy(const DestructiveCopy< P1 > &) | Loki::DestructiveCopy< P > | [inline]
Release(const P &) | Loki::DestructiveCopy< P > | [inline, static]
Swap(DestructiveCopy &) | Loki::DestructiveCopy< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NoCopy< P > Member List

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

Clone(const P &) | Loki::NoCopy< P > | [inline, static]
NoCopy() | Loki::NoCopy< P > | [inline]
NoCopy(const NoCopy< P1 > &) | Loki::NoCopy< P > | [inline]
Release(const P &) | Loki::NoCopy< P > | [inline, static]
Swap(NoCopy &) | Loki::NoCopy< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AllowConversion Member List

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

Swap(AllowConversion &) Loki::AllowConversion [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DisallowConversion Member List

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

DisallowConversion() | Loki::DisallowConversion | [inline]
DisallowConversion(const AllowConversion &) | Loki::DisallowConversion | [inline]
Swap(DisallowConversion &) | Loki::DisallowConversion | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NoCheck< P > Member List

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

NoCheck() | Loki::NoCheck< P > | [inline]
NoCheck(const NoCheck< P1 > &) | Loki::NoCheck< P > | [inline]
OnDefault(const P &) | Loki::NoCheck< P > | [inline, static]
OnDereference(const P &) | Loki::NoCheck< P > | [inline, static]
OnInit(const P &) | Loki::NoCheck< P > | [inline, static]
Swap(NoCheck &) | Loki::NoCheck< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AssertCheck< P > Member List

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

AssertCheck() | Loki::AssertCheck< P > | [inline]
AssertCheck(const AssertCheck< P1 > &) | Loki::AssertCheck< P > | [inline]
AssertCheck(const NoCheck< P1 > &) | Loki::AssertCheck< P > | [inline]
OnDefault(const P &) | Loki::AssertCheck< P > | [inline, static]
OnDereference(P val) | Loki::AssertCheck< P > | [inline, static]
OnInit(const P &) | Loki::AssertCheck< P > | [inline, static]
Swap(AssertCheck &) | Loki::AssertCheck< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AssertCheckStrict< P > Member List

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

AssertCheckStrict() | Loki::AssertCheckStrict< P > | [inline]
AssertCheckStrict(const AssertCheckStrict< U > &) | Loki::AssertCheckStrict< P > | [inline]
AssertCheckStrict(const AssertCheck< U > &) | Loki::AssertCheckStrict< P > | [inline]
AssertCheckStrict(const NoCheck< P1 > &) | Loki::AssertCheckStrict< P > | [inline]
OnDefault(P val) | Loki::AssertCheckStrict< P > | [inline, static]
OnDereference(P val) | Loki::AssertCheckStrict< P > | [inline, static]
OnInit(P val) | Loki::AssertCheckStrict< P > | [inline, static]
Swap(AssertCheckStrict &) | Loki::AssertCheckStrict< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NullPointerException Member List

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

NullPointerException() | Loki::NullPointerException | [inline]
what() const | Loki::NullPointerException | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RejectNullStatic< P > Member List

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

OnDefault(const P &) | Loki::RejectNullStatic< P > | [inline, static]
OnDereference(const P &val) | Loki::RejectNullStatic< P > | [inline, static]
OnInit(const P &val) | Loki::RejectNullStatic< P > | [inline, static]
RejectNullStatic() | Loki::RejectNullStatic< P > | [inline]
RejectNullStatic(const RejectNullStatic< P1 > &) | Loki::RejectNullStatic< P > | [inline]
RejectNullStatic(const NoCheck< P1 > &) | Loki::RejectNullStatic< P > | [inline]
RejectNullStatic(const AssertCheck< P1 > &) | Loki::RejectNullStatic< P > | [inline]
RejectNullStatic(const AssertCheckStrict< P1 > &) | Loki::RejectNullStatic< P > | [inline]
Swap(RejectNullStatic &) | Loki::RejectNullStatic< P > | [inline, static]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RejectNull< P > Member List

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

OnDefault(P) | Loki::RejectNull< P > | [inline, static]
OnDereference(P val) | Loki::RejectNull< P > | [inline]
OnDereference(P val) const | Loki::RejectNull< P > | [inline]
OnInit(P) | Loki::RejectNull< P > | [inline, static]
RejectNull() | Loki::RejectNull< P > | [inline]
RejectNull(const RejectNull< P1 > &) | Loki::RejectNull< P > | [inline]
Swap(RejectNull &) | Loki::RejectNull< P > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::RejectNullStrict< P > Member List

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

OnDereference(P val) | Loki::RejectNullStrict< P > | [inline]
OnDereference(P val) const | Loki::RejectNullStrict< P > | [inline]
OnInit(P val) | Loki::RejectNullStrict< P > | [inline, static]
RejectNullStrict() | Loki::RejectNullStrict< P > | [inline]
RejectNullStrict(const RejectNullStrict< P1 > &) | Loki::RejectNullStrict< P > | [inline]
RejectNullStrict(const RejectNull< P1 > &) | Loki::RejectNullStrict< P > | [inline]
Swap(RejectNullStrict &) | Loki::RejectNullStrict< P > | [inline]

Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Member List

This is the complete list of members for Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >, including all inherited members.

type typedef Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


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.

ConstPointerType typedef | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > |
ConstReferenceType typedef | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > |
CopyArg typedef | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > |
GetPointer(const SmartPtr &sp) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline, static]
Merge(SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator *() | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator *() const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator AutomaticConversionResult() const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator RefToValue() | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator unspecified_boolean_type() const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator!() const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator!=(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator->() | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator->() const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator<(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator<=(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator=(CopyArg &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator=(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator=(SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator==(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) const | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator>(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
operator>=(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
PointerType typedef | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > |
ReferenceType typedef | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > |
SmartPtr() | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
SmartPtr(ExplicitArg p) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline, explicit]
SmartPtr(ImplicitArg p) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
SmartPtr(CopyArg &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
SmartPtr(const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
SmartPtr(SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
SmartPtr(RefToValue< SmartPtr > rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
StoredType typedef | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > |
Swap(SmartPtr &rhs) | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]
~SmartPtr() | Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctionStorage< T > Member List

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

Default() | Loki::FunctionStorage< T > | [inline, protected, static]
Destroy() | Loki::FunctionStorage< T > | [inline, protected]
FunctionStorage() | Loki::FunctionStorage< T > | [inline]
FunctionStorage(const FunctionStorage &rsh) | Loki::FunctionStorage< T > | [inline]
FunctionStorage(const FunctionStorage< U > &rsh) | Loki::FunctionStorage< T > | [inline]
FunctionStorage(const StoredType &p) | Loki::FunctionStorage< T > | [inline]
FunctorType typedef | Loki::FunctionStorage< T > |
InitPointerType typedef | Loki::FunctionStorage< T > |
operator *() const | Loki::FunctionStorage< T > | [inline]
operator->() const | Loki::FunctionStorage< T > | [inline]
PointerType typedef | Loki::FunctionStorage< T > |
ReferenceType typedef | Loki::FunctionStorage< T > |
SetCallBackFunction(const FunctorType &functor) | Loki::FunctionStorage< T > | [inline]
StoredType typedef | Loki::FunctionStorage< T > |
Swap(FunctionStorage &rhs) | Loki::FunctionStorage< T > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


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.

encapsulate(AbstractProduct *pProduct) | Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > | [inline, protected]
name() | Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > | [inline, protected]
ProductReturn typedef | Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > | [protected]
release(ProductReturn &pProduct) | Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > | [inline, protected]
SmartPointer() | Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > | [inline, protected]
~SmartPointer() | Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > | [inline, protected, virtual]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


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]
Delete(const P *p) | Loki::DeleteUsingFree< P > | [inline, static]
Swap(DeleteUsingFree &) | Loki::DeleteUsingFree< P > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DeleteNothing< P > Member List

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

Default(void) | Loki::DeleteNothing< P > | [inline, static]
Delete(const P *) | Loki::DeleteNothing< P > | [inline, static]
Swap(DeleteNothing &) | Loki::DeleteNothing< P > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DeleteSingle< P > Member List

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

Default(void) | Loki::DeleteSingle< P > | [inline, static]
Delete(const P *p) | Loki::DeleteSingle< P > | [inline, static]
Swap(DeleteSingle &) | Loki::DeleteSingle< P > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DeleteArray< P > Member List

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

Default(void) | Loki::DeleteArray< P > | [inline, static]
Delete(const P *p) | Loki::DeleteArray< P > | [inline, static]
Swap(DeleteArray &) | Loki::DeleteArray< P > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::CantResetWithStrong< P > Member List

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

OnReleaseAll(bool hasStrongPtr) const | Loki::CantResetWithStrong< P > | [inline]
OnResetAll(bool hasStrongPtr) const | Loki::CantResetWithStrong< P > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::AllowReset< P > Member List

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

OnReleaseAll(bool) const | Loki::AllowReset< P > | [inline]
OnResetAll(bool) const | Loki::AllowReset< P > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::NeverReset< P > Member List

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

OnReleaseAll(bool) const | Loki::NeverReset< P > | [inline]
OnResetAll(bool) const | Loki::NeverReset< P > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TwoRefCounts Member List

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

Decrement(bool strong) | Loki::TwoRefCounts | [protected]
GetPointer(void) const | Loki::TwoRefCounts | [inline, protected]
GetPointerRef(void) const | Loki::TwoRefCounts | [inline, protected]
HasStrongPointer(void) const | Loki::TwoRefCounts | [inline, protected]
Increment(bool strong) | Loki::TwoRefCounts | [protected]
Release(bool strong) | Loki::TwoRefCounts | [inline, protected]
SetPointer(void *p) | Loki::TwoRefCounts | [inline, protected]
Swap(TwoRefCounts &rhs) | Loki::TwoRefCounts | [protected]
TwoRefCounts(bool strong) | Loki::TwoRefCounts | [explicit, protected]
TwoRefCounts(const void *p, bool strong) | Loki::TwoRefCounts | [protected]
TwoRefCounts(const TwoRefCounts &rhs, bool strong) | Loki::TwoRefCounts | [inline, protected]
ZapPointer(void) | Loki::TwoRefCounts | [protected]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TwoRefLinks Member List

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

GetPointer(void) const | Loki::TwoRefLinks | [inline, protected]
GetPointerRef(void) const | Loki::TwoRefLinks | [inline, protected]
HasStrongPointer(void) const | Loki::TwoRefLinks | [protected]
Merge(TwoRefLinks &rhs) | Loki::TwoRefLinks | [protected]
Release(bool strong) | Loki::TwoRefLinks | [protected]
SetPointer(void *p) | Loki::TwoRefLinks | [protected]
Swap(TwoRefLinks &rhs) | Loki::TwoRefLinks | [protected]
TwoRefLinks(bool strong) | Loki::TwoRefLinks | [inline, explicit, protected]
TwoRefLinks(const void *p, bool strong) | Loki::TwoRefLinks | [protected]
TwoRefLinks(const TwoRefLinks &rhs, bool strong) | Loki::TwoRefLinks | [protected]
ZapPointer(void) | Loki::TwoRefLinks | [inline, protected]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


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.

ConstPointerType typedef | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > |
ConstReferenceType typedef | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > |
Equals(const T1 *p) const | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
GetPointer(void) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline, protected]
GetPointer(void) const | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline, protected]
GreaterThan(const T1 *p) const | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
IsStrong(void) 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]
OP typedef | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > |
operator *() | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator *() const | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator AutomaticConversionResult() const | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator RefToValue(void) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator unspecified_boolean_type() const | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator!() 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->() | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator->() 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 &rhs) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator=(T *p) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
operator=(const 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]
PointerType typedef | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > |
ReferenceType typedef | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > |
StoredType typedef | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > |
StrongPtr(void) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
StrongPtr(ExplicitArg p) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline, explicit]
StrongPtr(ImplicitArg p) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
StrongPtr(const StrongPtr &rhs) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
StrongPtr(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
StrongPtr(StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
StrongPtr(RefToValue< StrongPtr > rhs) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
Swap(StrongPtr &rhs) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
Unlock(void) | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]
~StrongPtr() | Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Mutex Member List

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

Lock() | Loki::Mutex | [inline]
Mutex() | Loki::Mutex | [inline]
Unlock() | Loki::Mutex | [inline]
~Mutex() | Loki::Mutex | [inline]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


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.

AtomicAdd(volatile IntType &lval, IntType val) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
AtomicAssign(volatile IntType &lval, IntType val) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
AtomicAssign(IntType &lval, volatile IntType &val) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
AtomicDecrement(volatile IntType &lval) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
AtomicDivide(volatile IntType &lval, IntType val) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
AtomicIncrement(volatile IntType &lval) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
AtomicMultiply(volatile IntType &lval, IntType val) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
AtomicSubtract(volatile IntType &lval, IntType val) | Loki::SingleThreaded< Host, MutexPolicy > | [inline, static]
IntType typedef | Loki::SingleThreaded< Host, MutexPolicy > |
VolatileType typedef | Loki::SingleThreaded< Host, MutexPolicy > |

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

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

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

Lock() | Loki::SingleThreaded< Host, MutexPolicy >::Lock | [inline]
Lock(const SingleThreaded &) | Loki::SingleThreaded< Host, MutexPolicy >::Lock | [inline, explicit]
Lock(const SingleThreaded *) | Loki::SingleThreaded< Host, MutexPolicy >::Lock | [inline, explicit]

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Typelist< T, U > Member List

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

Head typedef | Loki::Typelist< T, U >
Tail typedef | Loki::Typelist< T, U >

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Int2Type< v > Member List

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

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Type2Type< T > Member List

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

OriginalType typedef Loki::Type2Type< T >

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Select< flag, T, U > Member List

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

Result typedef Loki::Select< flag, T, U >

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Select< false, T, U > Member List

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

Result typedef Loki::Select< false, T, U >

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::IsSameType< T, U > Member List

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

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::IsSameType< T, T > Member List

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

Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Conversion< T, U > Member List

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

H typedef Loki::Conversion< T, U >

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Conversion< T, T > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Conversion< void, T > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Conversion< T, void > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Conversion< void, void > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclass< T, U > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclass< void, void > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclass< void, U > Member List

This is the complete list of members for Loki::SuperSubclass< void, U >, including all inherited members.

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclass< T, void > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclassStrict< T, U > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclassStrict< void, void > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclassStrict< void, U > Member List

This is the complete list of members for Loki::SuperSubclassStrict< void, U >, including all inherited members.

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::SuperSubclassStrict< T, void > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::IsCustomUnsignedInt< T > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::IsCustomSignedInt< T > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::IsCustomFloat< T > Member List

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

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TypeTraits< T > Member List

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

NonConstType typedef | Loki::TypeTraits< T >
NonVolatileType typedef | Loki::TypeTraits< T >
ParameterType typedef | Loki::TypeTraits< T >
PointeeType typedef | Loki::TypeTraits< T >
ReferredType typedef | Loki::TypeTraits< T >
UnqualifiedType typedef | Loki::TypeTraits< T >

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::BaseVisitor Member List

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

~BaseVisitor() Loki::BaseVisitor [inline, virtual]

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Visitor< T, R, false > Member List

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

ParamType typedef | Loki::Visitor< T, R, false > |
ReturnType typedef | Loki::Visitor< T, R, false > |
~Visitor() | Loki::Visitor< T, R, false > | [inline, virtual]

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Visitor< T, R, true > Member List

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

ParamType typedef | Loki::Visitor< T, R, true > |
ReturnType typedef | Loki::Visitor< T, R, true > |
~Visitor() | Loki::Visitor< T, R, true > | [inline, virtual]

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Visitor< Typelist< Head, Tail >, R, false > Member List

This is the complete list of members for Loki::Visitor< Typelist< Head, Tail >, R, false >, including all inherited members.

ReturnType typedef Loki::Visitor< Typelist< Head, Tail >, R, false >

Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Visitor< Typelist< Head, NullType >, R, false > Member List

This is the complete list of members for Loki::Visitor< Typelist< Head, NullType >, R, false >, including all inherited members.

ReturnType typedef Loki::Visitor< Typelist< Head, NullType >, R, false >

Generated on Sat Jul 7 15:12:19 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Visitor< Typelist< Head, Tail >, R, true > Member List

This is the complete list of members for Loki::Visitor< Typelist< Head, Tail >, R, true >, including all inherited members.

ReturnType typedef Loki::Visitor< Typelist< Head, Tail >, R, true >

Generated on Sat Jul 7 15:12:19 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Visitor< Typelist< Head, NullType >, R, true > Member List

This is the complete list of members for Loki::Visitor< Typelist< Head, NullType >, R, true >, including all inherited members.

ReturnType typedef Loki::Visitor< Typelist< Head, NullType >, R, true >

Generated on Sat Jul 7 15:12:19 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::BaseVisitorImpl< Typelist< Head, Tail >, R > Member List

This is the complete list of members for Loki::BaseVisitorImpl< Typelist< Head, Tail >, R >, including all inherited members.

Visit(Head &) Loki::BaseVisitorImpl< Typelist< Head, Tail >, R > [inline, virtual]

Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::BaseVisitorImpl< Typelist< Head, NullType >, R > Member List

This is the complete list of members for Loki::BaseVisitorImpl< Typelist< Head, NullType >, R >, including all inherited members.

Visit(Head &) Loki::BaseVisitorImpl< Typelist< Head, NullType >, R > [inline, virtual]

Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::DefaultCatchAll< R, Visited > Member List

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

OnUnknownVisitor(Visited &, BaseVisitor &) Loki::DefaultCatchAll< R, Visited > [inline, static]

Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::BaseVisitable< R, CatchAll, false > Member List

This is the complete list of members for Loki::BaseVisitable< R, CatchAll, false >, including all inherited members.

AcceptImpl(T &visited, BaseVisitor &guest) | Loki::BaseVisitable< R, CatchAll, false > | [inline, protected, static]
ReturnType typedef | Loki::BaseVisitable< R, CatchAll, false > |
~BaseVisitable() | Loki::BaseVisitable< R, CatchAll, false > | [inline, virtual]

Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::BaseVisitable< R, CatchAll, true > Member List

This is the complete list of members for Loki::BaseVisitable< R, CatchAll, true >, including all inherited members.

AcceptImpl(const T &visited, BaseVisitor &guest) | Loki::BaseVisitable< R, CatchAll, true > | [inline, protected, static]
ReturnType typedef | Loki::BaseVisitable< R, CatchAll, true > |
~BaseVisitable() | Loki::BaseVisitable< R, CatchAll, true > | [inline, virtual]

Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


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.

GenericVisit(Visited &host) | Loki::CyclicVisitor< R, TList > | [inline]
ReturnType typedef | Loki::CyclicVisitor< R, TList > |

Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Chunk Member List

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

FixedAllocator class Loki::Chunk [friend]

Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


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 |
HasBlock(void *p) | Loki::FixedAllocator | [inline]
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 Sat Jul 7 15:12:21 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::OrderedStatic< L, T, Loki::NullType > Member List

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

createObject() | Loki::OrderedStatic< L, T, Loki::NullType > | [inline, virtual]
operator *() | Loki::Private::OrderedStaticBase< T > | [inline]
operator->() | Loki::Private::OrderedStaticBase< T > | [inline]
OrderedStatic() | Loki::OrderedStatic< L, T, Loki::NullType > | [inline]
OrderedStaticBase(unsigned int longevity) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected]
SetLongevity(T *ptr) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
~OrderedStaticBase() | Loki::Private::OrderedStaticBase< T > | [inline, protected, virtual]
~OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected, virtual]

Generated on Sat Jul 7 15:12:22 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::OrderedStatic< L, T, Loki::Seq< P1 > > Member List

This is the complete list of members for Loki::OrderedStatic< L, T, Loki::Seq< P1 > >, including all inherited members.

createObject() | Loki::OrderedStatic< L, T, Loki::Seq< P1 > > | [inline, virtual]
operator *() | Loki::Private::OrderedStaticBase< T > | [inline]
operator->() | Loki::Private::OrderedStaticBase< T > | [inline]
OrderedStatic(P1 p) | Loki::OrderedStatic< L, T, Loki::Seq< P1 > > | [inline]
OrderedStaticBase(unsigned int longevity) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected]
SetLongevity(T *ptr) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
~OrderedStaticBase() | Loki::Private::OrderedStaticBase< T > | [inline, protected, virtual]
~OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected, virtual]

Generated on Sat Jul 7 15:12:22 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >>, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImplBase |
Parm3 typedef | Loki::FactoryImplBase |
Parm4 typedef | Loki::FactoryImplBase |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> | [inline, virtual]

Generated on Sat Jul 7 15:12:22 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm3 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:23 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >>, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> |
Parm3 typedef | Loki::FactoryImplBase |
Parm4 typedef | Loki::FactoryImplBase |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:23 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > |
Parm3 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:23 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >>, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> |
Parm3 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> |
Parm4 typedef | Loki::FactoryImplBase |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:24 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:24 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >>, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> |
Parm3 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> |
Parm4 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> |
Parm5 typedef | Loki::FactoryImplBase |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:25 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:25 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >>, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> |
Parm3 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> |
Parm4 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> |
Parm5 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> |
Parm6 typedef | Loki::FactoryImplBase |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:25 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:26 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> Member List

This is the complete list of members for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >>, including all inherited members.

Parm1 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> |
Parm3 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> |
Parm4 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> |
Parm5 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> |
Parm6 typedef | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> |
Parm7 typedef | Loki::FactoryImplBase |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:26 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > Member List

This is the complete list of members for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
Parm3 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
Parm4 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
Parm5 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
Parm6 typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:26 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > >> |
Parm8 typedef | Loki::FactoryImplBase |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::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 > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:27 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:27 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > >> |
Parm9 typedef | Loki::FactoryImplBase |
~FactoryImpl() | Loki::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 > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:28 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:28 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > > >> |
Parm10 typedef | Loki::FactoryImplBase |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > > >> |
Parm9 typedef | Loki::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 > > > > > > > > >> |
~FactoryImpl() | Loki::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 > > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:28 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::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 > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:29 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > > > >> |
Parm10 typedef | Loki::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 > > > > > > > > > >> |
Parm11 typedef | Loki::FactoryImplBase |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > > > >> |
Parm9 typedef | Loki::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 > > > > > > > > > >> |
~FactoryImpl() | Loki::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 > > > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:29 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::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 > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::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 > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:29 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > > > > >> |
Parm10 typedef | Loki::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 > > > > > > > > > > >> |
Parm11 typedef | Loki::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 > > > > > > > > > > >> |
Parm12 typedef | Loki::FactoryImplBase |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > > > > >> |
Parm9 typedef | Loki::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 > > > > > > > > > > >> |
~FactoryImpl() | Loki::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 > > > > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:30 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::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 > |
Parm11 typedef | Loki::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 > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::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 > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:30 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > > > > > >> |
Parm10 typedef | Loki::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 > > > > > > > > > > > >> |
Parm11 typedef | Loki::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 > > > > > > > > > > > >> |
Parm12 typedef | Loki::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 > > > > > > > > > > > >> |
Parm13 typedef | Loki::FactoryImplBase |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > > > > > >> |
Parm9 typedef | Loki::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 > > > > > > > > > > > >> |
~FactoryImpl() | Loki::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 > > > > > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:31 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::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 > |
Parm11 typedef | Loki::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 > |
Parm12 typedef | Loki::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 > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::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 > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:31 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm10 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm11 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm12 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm13 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm14 typedef | Loki::FactoryImplBase |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > > > > > > >> |
Parm9 typedef | Loki::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 > > > > > > > > > > > > >> |
~FactoryImpl() | Loki::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 > > > > > > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:31 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::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 > |
Parm11 typedef | Loki::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 > |
Parm12 typedef | Loki::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 > |
Parm13 typedef | Loki::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 > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::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 > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:32 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm10 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm11 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm12 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm13 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm14 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm15 typedef | Loki::FactoryImplBase |
Parm2 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > > > > > > > >> |
Parm9 typedef | Loki::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 > > > > > > > > > > > > > >> |
~FactoryImpl() | Loki::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 > > > > > > > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:32 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::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 > |
Parm11 typedef | Loki::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 > |
Parm12 typedef | Loki::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 > |
Parm13 typedef | Loki::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 > |
Parm14 typedef | Loki::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 > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::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 > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:33 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > > > > > > > > > > > > > > >> Member List

This is the complete list of members for Loki::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 > > > > > > > > > > > > > > >>, including all inherited members.

Parm1 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm10 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm11 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm12 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm13 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm14 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm15 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm2 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm3 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm4 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm5 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm6 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm7 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm8 typedef | Loki::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 > > > > > > > > > > > > > > >> |
Parm9 typedef | Loki::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 > > > > > > > > > > > > > > >> |
~FactoryImpl() | Loki::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 > > > > > > > > > > > > > > >> | [inline, virtual]

Generated on Sat Jul 7 15:12:33 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::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 > Member List

This is the complete list of members for Loki::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 >, including all inherited members.

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::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 > |
Parm10 typedef | Loki::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 > |
Parm11 typedef | Loki::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 > |
Parm12 typedef | Loki::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 > |
Parm13 typedef | Loki::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 > |
Parm14 typedef | Loki::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 > |
Parm15 typedef | Loki::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 > |
Parm2 typedef | Loki::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 > |
Parm3 typedef | Loki::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 > |
Parm4 typedef | Loki::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 > |
Parm5 typedef | Loki::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 > |
Parm6 typedef | Loki::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 > |
Parm7 typedef | Loki::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 > |
Parm8 typedef | Loki::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 > |
Parm9 typedef | Loki::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 > |
ResultType typedef | Loki::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 > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:34 2007 for Loki by doxygen 1.5.1-p1


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.

OnDeadReference() | Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > | [inline, static]
ScheduleDestruction(T *pObj, atexit_pfn_t pFun) | Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > | [inline, static]
~SingletonFixedLongevity() | Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > | [inline, virtual]

Generated on Sat Jul 7 15:12:34 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AssocVectorCompare< Value, C > Member List

This is the complete list of members for Loki::Private::AssocVectorCompare< Value, C >, including all inherited members.

AssocVectorCompare() | Loki::Private::AssocVectorCompare< Value, C > | [inline]
AssocVectorCompare(const C &src) | Loki::Private::AssocVectorCompare< Value, C > | [inline]
operator()(const first_argument_type &lhs, const first_argument_type &rhs) const | Loki::Private::AssocVectorCompare< Value, C > | [inline]
operator()(const Data &lhs, const Data &rhs) const | Loki::Private::AssocVectorCompare< Value, C > | [inline]
operator()(const Data &lhs, const first_argument_type &rhs) const | Loki::Private::AssocVectorCompare< Value, C > | [inline]
operator()(const first_argument_type &lhs, const Data &rhs) const | Loki::Private::AssocVectorCompare< Value, C > | [inline]

Generated on Sat Jul 7 15:12:36 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::FunctorImplBase< R, ThreadingModel > Member List

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

Clone(U *pObj) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, static]
FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBase(const FunctorImplBase &) | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline]
FunctorImplBaseType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ObjAllocatorSingleton typedef | Loki::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]
operator=(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
Loki::SmallObjectBase::operator=(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
Parm1 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm10 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm11 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm12 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm13 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm14 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm15 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm2 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm3 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm4 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm5 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm6 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm7 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm8 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
Parm9 typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
ResultType typedef | Loki::Private::FunctorImplBase< R, ThreadingModel > |
SmallObjectBase(void) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallObjectBase(const SmallObjectBase &) | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
SmallValueObject(void) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
SmallValueObject(const SmallValueObject &) | Loki::SmallValueObject< ThreadingModel > | [inline, protected]
~FunctorImplBase() | Loki::Private::FunctorImplBase< R, ThreadingModel > | [inline, virtual]
~SmallObjectBase() | Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > | [inline, protected]
~SmallValueObject() | Loki::SmallValueObject< ThreadingModel > | [inline, protected]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

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

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

BoundFunctorType typedef | Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
Impl typedef | Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
OriginalFunctor typedef | Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
OriginalParm1 typedef | Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
ParmList typedef | Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::BinderFirstBoundTypeStorage< T > Member List

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

RefOrValue typedef Loki::Private::BinderFirstBoundTypeStorage< T >

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

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

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

OriginalFunctor typedef | Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > >
RefOrValue typedef | Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > >

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType > Member List

This is the complete list of members for Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType >, including all inherited members.

DoDispatch(SomeLhs &lhs, SomeRhs &rhs, Executor &exec, Int2Type< false >) | Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType > | [inline, static]
DoDispatch(SomeLhs &lhs, SomeRhs &rhs, Executor &exec, Int2Type< true >) | Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType > | [inline, static]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback > Member List

This is the complete list of members for Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback >, including all inherited members.

Trampoline(BaseLhs &lhs, BaseRhs &rhs) | Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback > | [inline, static]
TrampolineR(BaseRhs &rhs, BaseLhs &lhs) | Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback > | [inline, static]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs > Member List

This is the complete list of members for Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs >, including all inherited members.

FunctorDispatcherHelper(const Fun &fun) | Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs > | [inline]
operator()(BaseLhs &lhs, BaseRhs &rhs) | Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs > | [inline]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::OrderedStaticCreatorFunc Member List

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

OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected]
~OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected, virtual]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::OrderedStaticBase< T > Member List

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

operator *() | Loki::Private::OrderedStaticBase< T > | [inline]
operator->() | Loki::Private::OrderedStaticBase< T > | [inline]
OrderedStaticBase(unsigned int longevity) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected]
SetLongevity(T *ptr) | Loki::Private::OrderedStaticBase< T > | [inline, protected]
~OrderedStaticBase() | Loki::Private::OrderedStaticBase< T > | [inline, protected, virtual]
~OrderedStaticCreatorFunc() | Loki::Private::OrderedStaticCreatorFunc | [protected, virtual]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::OrderedStaticManagerClass Member List

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

createObjects() | Loki::Private::OrderedStaticManagerClass |
Creator typedef | Loki::Private::OrderedStaticManagerClass |
OrderedStaticManagerClass() | Loki::Private::OrderedStaticManagerClass |
registerObject(unsigned int longevity, OrderedStaticCreatorFunc *, Creator) | Loki::Private::OrderedStaticManagerClass |
~OrderedStaticManagerClass() | Loki::Private::OrderedStaticManagerClass | [virtual]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::RegisterOnCreate< T > Member List

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

RegisterOnCreate() Loki::Private::RegisterOnCreate< T > [inline]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::UnRegisterOnDelete< T > Member List

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

~UnRegisterOnDelete() Loki::Private::UnRegisterOnDelete< T > [inline]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::RegisterOnCreateElement< T > Member List

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

registerObj Loki::Private::RegisterOnCreateElement< T >

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::UnRegisterOnDeleteElement< T > Member List

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

unregisterObj Loki::Private::UnRegisterOnDeleteElement< T >

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::LifetimeTracker Member List

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

Compare(const LifetimeTracker *lhs, const LifetimeTracker *rhs) | Loki::Private::LifetimeTracker | [inline, static]
LifetimeTracker(unsigned int x) | Loki::Private::LifetimeTracker | [inline]
~LifetimeTracker()=0 | Loki::Private::LifetimeTracker | [inline, pure virtual]

Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::Deleter< T > Member List

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

Delete(T *pObj) | Loki::Private::Deleter< T > | [inline, static]
Type typedef | Loki::Private::Deleter< T > |

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::ConcreteLifetimeTracker< T, Destroyer > Member List

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

Compare(const LifetimeTracker *lhs, const LifetimeTracker *rhs) | Loki::Private::LifetimeTracker | [inline, static]
ConcreteLifetimeTracker(T *p, unsigned int longevity, Destroyer d) | Loki::Private::ConcreteLifetimeTracker< T, Destroyer > | [inline]
LifetimeTracker(unsigned int x) | Loki::Private::LifetimeTracker | [inline]
~ConcreteLifetimeTracker() | Loki::Private::ConcreteLifetimeTracker< T, Destroyer > | [inline]
~LifetimeTracker()=0 | Loki::Private::LifetimeTracker | [inline, pure virtual]

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::Adapter< T > Member List

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

operator()(T *) | Loki::Private::Adapter< T > | [inline]
pFun_ | Loki::Private::Adapter< T > |

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::RefLinkedBase Member List

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

Merge(RefLinkedBase &rhs) | Loki::Private::RefLinkedBase |
RefLinkedBase() | Loki::Private::RefLinkedBase | [inline]
RefLinkedBase(const RefLinkedBase &rhs) | Loki::Private::RefLinkedBase |
Release() | Loki::Private::RefLinkedBase |
Swap(RefLinkedBase &rhs) | Loki::Private::RefLinkedBase |

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::TwoRefCountInfo Member List

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

DecStrongCount(void) | Loki::Private::TwoRefCountInfo | [inline]
DecWeakCount(void) | Loki::Private::TwoRefCountInfo | [inline]
GetPointer(void) const | Loki::Private::TwoRefCountInfo | [inline]
GetPointerRef(void) const | Loki::Private::TwoRefCountInfo | [inline]
HasStrongPointer(void) const | Loki::Private::TwoRefCountInfo | [inline]
HasWeakPointer(void) const | Loki::Private::TwoRefCountInfo | [inline]
IncStrongCount(void) | Loki::Private::TwoRefCountInfo | [inline]
IncWeakCount(void) | Loki::Private::TwoRefCountInfo | [inline]
SetPointer(void *p) | Loki::Private::TwoRefCountInfo | [inline]
TwoRefCountInfo(bool strong) | Loki::Private::TwoRefCountInfo | [inline, explicit]
TwoRefCountInfo(void *p, bool strong) | Loki::Private::TwoRefCountInfo | [inline]
ZapPointer(void) | Loki::Private::TwoRefCountInfo | [inline]
~TwoRefCountInfo(void) | Loki::Private::TwoRefCountInfo | [inline]

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::ConversionHelper< T, U > Member List

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

Small typedef Loki::Private::ConversionHelper< T, U >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::ConversionHelper< T, U >::Big Member List

This is the complete list of members for Loki::Private::ConversionHelper< T, U >::Big, including all inherited members.

dummy Loki::Private::ConversionHelper< T, U >::Big

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddPointer< U > Member List

This is the complete list of members for Loki::Private::AddPointer< U >, including all inherited members.

Result typedef Loki::Private::AddPointer< U >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddPointer< U & > Member List

This is the complete list of members for Loki::Private::AddPointer< U & >, including all inherited members.

Result typedef Loki::Private::AddPointer< U & >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddReference< U > Member List

This is the complete list of members for Loki::Private::AddReference< U >, including all inherited members.

Result typedef Loki::Private::AddReference< U >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddReference< U & > Member List

This is the complete list of members for Loki::Private::AddReference< U & >, including all inherited members.

Result typedef Loki::Private::AddReference< U & >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddReference< void > Member List

This is the complete list of members for Loki::Private::AddReference< void >, including all inherited members.

Result typedef Loki::Private::AddReference< void >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddParameterType< U > Member List

This is the complete list of members for Loki::Private::AddParameterType< U >, including all inherited members.

Result typedef Loki::Private::AddParameterType< U >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddParameterType< U & > Member List

This is the complete list of members for Loki::Private::AddParameterType< U & >, including all inherited members.

Result typedef Loki::Private::AddParameterType< U & >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::AddParameterType< void > Member List

This is the complete list of members for Loki::Private::AddParameterType< void >, including all inherited members.

Result typedef Loki::Private::AddParameterType< void >

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T > Member List

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

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)()> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)()>, including all inherited members.

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01)>, including all inherited members.

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)>, including all inherited members.

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)>, including all inherited members.

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)>, including all inherited members.

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)>, including all inherited members.

Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> Member List

This is the complete list of members for Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T > Member List

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

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile > Member List

This is the complete list of members for Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile >, including all inherited members.

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::nameof_type< T > Member List

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

operator()() Loki::TL::nameof_type< T > [inline]

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::sizeof_type< T > Member List

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

operator()() Loki::TL::sizeof_type< T > [inline]

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > Member List

This is the complete list of members for Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >, including all inherited members.

head | Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > |
head_t typedef | Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > |
operator()(II ii) | Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > | [inline]
tail | Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > |
tail_t typedef | Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > |

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::IterateTypes< AtomicType, GenFunc > Member List

This is the complete list of members for Loki::TL::IterateTypes< AtomicType, GenFunc >, including all inherited members.

operator()(II ii) Loki::TL::IterateTypes< AtomicType, GenFunc > [inline]

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::IterateTypes< NullType, GenFunc > Member List

This is the complete list of members for Loki::TL::IterateTypes< NullType, GenFunc >, including all inherited members.

operator()(II ii) Loki::TL::IterateTypes< NullType, GenFunc > [inline]

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 > Member List

This is the complete list of members for Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >, including all inherited members.

Result typedef Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::MakeTypelist<> Member List

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

Result typedef Loki::TL::MakeTypelist<>

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Length< NullType > Member List

This is the complete list of members for Loki::TL::Length< NullType >, including all inherited members.

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Length< Typelist< T, U > > Member List

This is the complete list of members for Loki::TL::Length< Typelist< T, U > >, including all inherited members.

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::TypeAt< Typelist< Head, Tail >, 0 > Member List

This is the complete list of members for Loki::TL::TypeAt< Typelist< Head, Tail >, 0 >, including all inherited members.

Result typedef Loki::TL::TypeAt< Typelist< Head, Tail >, 0 >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::TypeAt< Typelist< Head, Tail >, i > Member List

This is the complete list of members for Loki::TL::TypeAt< Typelist< Head, Tail >, i >, including all inherited members.

Result typedef Loki::TL::TypeAt< Typelist< Head, Tail >, i >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::TypeAtNonStrict< TList, index, DefaultType > Member List

This is the complete list of members for Loki::TL::TypeAtNonStrict< TList, index, DefaultType >, including all inherited members.

Result typedef Loki::TL::TypeAtNonStrict< TList, index, DefaultType >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType > Member List

This is the complete list of members for Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType >, including all inherited members.

Result typedef Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType > Member List

This is the complete list of members for Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType >, including all inherited members.

Result typedef Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::IndexOf< NullType, T > Member List

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

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::IndexOf< Typelist< T, Tail >, T > Member List

This is the complete list of members for Loki::TL::IndexOf< Typelist< T, Tail >, T >, including all inherited members.

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::IndexOf< Typelist< Head, Tail >, T > Member List

This is the complete list of members for Loki::TL::IndexOf< Typelist< Head, Tail >, T >, including all inherited members.

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Append< NullType, NullType > Member List

This is the complete list of members for Loki::TL::Append< NullType, NullType >, including all inherited members.

Result typedef Loki::TL::Append< NullType, NullType >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Append< NullType, T > Member List

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

Result typedef Loki::TL::Append< NullType, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Append< NullType, Typelist< Head, Tail > > Member List

This is the complete list of members for Loki::TL::Append< NullType, Typelist< Head, Tail > >, including all inherited members.

Result typedef Loki::TL::Append< NullType, Typelist< Head, Tail > >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Append< Typelist< Head, Tail >, T > Member List

This is the complete list of members for Loki::TL::Append< Typelist< Head, Tail >, T >, including all inherited members.

Result typedef Loki::TL::Append< Typelist< Head, Tail >, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Erase< NullType, T > Member List

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

Result typedef Loki::TL::Erase< NullType, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Erase< Typelist< T, Tail >, T > Member List

This is the complete list of members for Loki::TL::Erase< Typelist< T, Tail >, T >, including all inherited members.

Result typedef Loki::TL::Erase< Typelist< T, Tail >, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Erase< Typelist< Head, Tail >, T > Member List

This is the complete list of members for Loki::TL::Erase< Typelist< Head, Tail >, T >, including all inherited members.

Result typedef Loki::TL::Erase< Typelist< Head, Tail >, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::EraseAll< NullType, T > Member List

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

Result typedef Loki::TL::EraseAll< NullType, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::EraseAll< Typelist< T, Tail >, T > Member List

This is the complete list of members for Loki::TL::EraseAll< Typelist< T, Tail >, T >, including all inherited members.

Result typedef Loki::TL::EraseAll< Typelist< T, Tail >, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::EraseAll< Typelist< Head, Tail >, T > Member List

This is the complete list of members for Loki::TL::EraseAll< Typelist< Head, Tail >, T >, including all inherited members.

Result typedef Loki::TL::EraseAll< Typelist< Head, Tail >, T >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::NoDuplicates< NullType > Member List

This is the complete list of members for Loki::TL::NoDuplicates< NullType >, including all inherited members.

Result typedef Loki::TL::NoDuplicates< NullType >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::NoDuplicates< Typelist< Head, Tail > > Member List

This is the complete list of members for Loki::TL::NoDuplicates< Typelist< Head, Tail > >, including all inherited members.

Result typedef Loki::TL::NoDuplicates< Typelist< Head, Tail > >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Replace< NullType, T, U > Member List

This is the complete list of members for Loki::TL::Replace< NullType, T, U >, including all inherited members.

Result typedef Loki::TL::Replace< NullType, T, U >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Replace< Typelist< T, Tail >, T, U > Member List

This is the complete list of members for Loki::TL::Replace< Typelist< T, Tail >, T, U >, including all inherited members.

Result typedef Loki::TL::Replace< Typelist< T, Tail >, T, U >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Replace< Typelist< Head, Tail >, T, U > Member List

This is the complete list of members for Loki::TL::Replace< Typelist< Head, Tail >, T, U >, including all inherited members.

Result typedef Loki::TL::Replace< Typelist< Head, Tail >, T, U >

Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::ReplaceAll< NullType, T, U > Member List

This is the complete list of members for Loki::TL::ReplaceAll< NullType, T, U >, including all inherited members.

Result typedef Loki::TL::ReplaceAll< NullType, T, U >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U > Member List

This is the complete list of members for Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U >, including all inherited members.

Result typedef Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U > Member List

This is the complete list of members for Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U >, including all inherited members.

Result typedef Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Reverse< NullType > Member List

This is the complete list of members for Loki::TL::Reverse< NullType >, including all inherited members.

Result typedef Loki::TL::Reverse< NullType >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::Reverse< Typelist< Head, Tail > > Member List

This is the complete list of members for Loki::TL::Reverse< Typelist< Head, Tail > >, including all inherited members.

Result typedef Loki::TL::Reverse< Typelist< Head, Tail > >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::MostDerived< NullType, T > Member List

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

Result typedef Loki::TL::MostDerived< NullType, T >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::MostDerived< Typelist< Head, Tail >, T > Member List

This is the complete list of members for Loki::TL::MostDerived< Typelist< Head, Tail >, T >, including all inherited members.

Result typedef Loki::TL::MostDerived< Typelist< Head, Tail >, T >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::DerivedToFront< NullType > Member List

This is the complete list of members for Loki::TL::DerivedToFront< NullType >, including all inherited members.

Result typedef Loki::TL::DerivedToFront< NullType >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

Loki::TL::DerivedToFront< Typelist< Head, Tail > > Member List

This is the complete list of members for Loki::TL::DerivedToFront< Typelist< Head, Tail > >, including all inherited members.

Result typedef Loki::TL::DerivedToFront< Typelist< Head, Tail > >

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Member List

std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > > Member List

This is the complete list of members for std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > >, including all inherited members.

operator()(const Loki::SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, const Loki::SmartPtr< T, OP, CP, KP, SP, CNP > &rhs) const std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > > [inline]

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


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.

operator()(const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &lhs, const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs) const std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > [inline]

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Class List

Loki Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Loki::AbstractFactory< TList, Unit > |
AbstractFactory | Implements an abstract object factory
Loki::AbstractFactoryUnit< T > |
Loki::Private::Adapter< T > |
Loki::Private::AddParameterType< U > |
Loki::Private::AddParameterType< U & > |
Loki::Private::AddParameterType< void > |
Loki::Private::AddPointer< U > |
Loki::Private::AddPointer< U & > |
Loki::Private::AddReference< U > |
Loki::Private::AddReference< U & > |
Loki::Private::AddReference< void > |
Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > |
Loki::AllowConversion |
Loki::AllowReset< P > |
Loki::AlwaysCreate | Always allows creation
Loki::AmountLimitedCreation | Limit by number of objects
Loki::TL::Append< NullType, NullType > |
Loki::TL::Append< NullType, T > |
Loki::TL::Append< NullType, Typelist< Head, Tail > > |
Loki::TL::Append< Typelist< Head, Tail >, T > |
Loki::ArrayStorage< T > |
Loki::AssertCheck< P > |
Loki::AssertCheckStrict< P > |
Loki::AssocVector< K, V, C, A > |
Loki::AssocVector< K, V, C, A >::value_compare |
Loki::Private::AssocVectorCompare< Value, C > |
Loki::BaseVisitable< R, CatchAll, false > |
Loki::BaseVisitable< R, CatchAll, true > |
Loki::BaseVisitor |
Loki::BaseVisitorImpl< Typelist< Head, NullType >, R > |
Loki::BaseVisitorImpl< Typelist< Head, Tail >, R > |
Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > |
Loki::BinderFirst< OriginalFunctor > |
Loki::Private::BinderFirstBoundTypeStorage< T > |
Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > > |
Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > > |
Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > | Factory with caching support
Loki::CacheException |
Loki::CantResetWithStrong< P > |
Loki::Chainer< Fun1, Fun2 > |
Loki::Chunk |
Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > | Creates a copy from a polymorphic object
Loki::CompileTimeError< true > |
Loki::COMRefCounted< P > |
Loki::ConcreteFactory< AbstractFact, Creator, TList > |
Loki::Private::ConcreteLifetimeTracker< T, Destroyer > |
Loki::ConstPropPtr< T > |
Loki::Conversion< T, U > |
Loki::Conversion< T, T > |
Loki::Conversion< T, void > |
Loki::Conversion< void, T > |
Loki::Conversion< void, void > |
Loki::Private::ConversionHelper< T, U > |
Loki::Private::ConversionHelper< T, U >::Big |
Loki::CreateStatic< T > |
Loki::CreateStatic< T >::MaxAlign |
Loki::CreateUsing< Alloc > |
Loki::CreateUsing< Alloc >::Allocator< T > |
Loki::CreateUsingMalloc< T > |
Loki::CreateUsingNew< T > |
Loki::CyclicVisitor< R, TList > |
Loki::DeepCopy< P > |
Loki::DefaultCatchAll< R, Visited > |
Loki::DefaultFactoryError< IdentifierType, AbstractProduct > | Default policy that throws an exception
Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception |
Loki::DefaultLifetime< T > |
Loki::DefaultSPStorage< T > |
Loki::DeletableSingleton< T > |
Loki::DeleteArray< P > |
Loki::DeleteNothing< P > |
Loki::Private::Deleter< T > |
Loki::DeleteSingle< P > |
Loki::DeleteUsingFree< P > |
Loki::TL::DerivedToFront< NullType > |
Loki::TL::DerivedToFront< Typelist< Head, Tail > > |
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::DynamicCaster< To, From > |
Loki::EmptyType |
Loki::TL::Erase< NullType, T > |
Loki::TL::Erase< Typelist< Head, Tail >, T > |
Loki::TL::Erase< Typelist< T, Tail >, T > |
Loki::TL::EraseAll< NullType, T > |
Loki::TL::EraseAll< Typelist< Head, Tail >, T > |
Loki::TL::EraseAll< Typelist< T, Tail >, T > |
Loki::EvictAging< DT, ST > | LRU aware of the time span of use
Loki::EvictionException |
Loki::EvictionHelper< ST, DT > |
Loki::EvictLRU< DT, ST > | Evicts least accessed objects first
Loki::EvictRandom< DT, ST > | Evicts a random object
Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > |
Loki::FactoryImpl< AP, Id, NullType > |
Loki::FactoryImpl< AP, Id, Seq< P1 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > |
Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > |
Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> |
Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> |
Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> |
Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> |
Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> |
Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> |
Loki::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 > > > > > > >> |
Loki::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 > > > > > > > >> |
Loki::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 > > > > > > > > >> |
Loki::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 > > > > > > > > > >> |
Loki::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 > > > > > > > > > > >> |
Loki::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 > > > > > > > > > > > >> |
Loki::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 > > > > > > > > > > > > >> |
Loki::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 > > > > > > > > > > > > > >> |
Loki::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 > > > > > > > > > > > > > > >> |
Loki::FactoryImplBase |
Loki::FieldHelper< H, i > |
Loki::FieldHelper< H, 0 > |
Loki::FixedAllocator |
Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > |
Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback > |
Loki::FollowIntoDeath |
Loki::FollowIntoDeath::AfterMaster< Master > |
Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F > |
Loki::FollowIntoDeath::With< Lifetime > |
Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master > |
Function |
Loki::Function< R()> |
Loki::Function< R(P01)> |
Loki::Function< R(P01, P02)> |
Loki::Function< R(P01, P02, P03)> |
Loki::Function< R(P01, P02, P03, P04)> |
Loki::Function< R(P01, P02, P03, P04, P05)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> |
Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> |
Loki::Function<> |
Loki::FunctionStorage< T > | Implementation of the StoragePolicy used by SmartPtr
Loki::Functor< R, TList, ThreadingModel > |
Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > |
Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs > |
Loki::FunctorHandler< ParentFunctor, Fun > |
Loki::FunctorImpl< R, NullType, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > |
Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > |
Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > |
Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > |
Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > |
Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > |
Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > |
Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > |
Loki::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 > |
Loki::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 > |
Loki::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 > |
Loki::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 > |
Loki::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 > |
Loki::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 > |
Loki::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 > |
Loki::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 > |
Loki::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 > |
Loki::Private::FunctorImplBase< R, ThreadingModel > |
Loki::GenLinearHierarchy< NullType, Unit, Root > |
Loki::GenLinearHierarchy< Typelist< T, NullType >, Unit, Root > |
Loki::GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root > |
Loki::GenScatterHierarchy< AtomicType, Unit > |
Loki::GenScatterHierarchy< NullType, Unit > |
Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit > |
Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > |
Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T > |
Loki::HeapStorage< T > |
ImplOf |
Loki::TL::IndexOf< NullType, T > |
Loki::TL::IndexOf< Typelist< Head, Tail >, T > |
Loki::TL::IndexOf< Typelist< T, Tail >, T > |
Loki::Int2Type< v > |
Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType > |
Loki::IsCustomFloat< T > |
Loki::IsCustomSignedInt< T > |
Loki::IsCustomUnsignedInt< T > |
Loki::Private::IsFunctionPointerRaw< T > |
Loki::Private::IsFunctionPointerRaw< T(*)()> |
Loki::Private::IsFunctionPointerRaw< T(*)(...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)> |
Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)> |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile > |
Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)> |
Loki::IsSameType< T, U > |
Loki::IsSameType< T, T > |
Loki::TL::IterateTypes< AtomicType, GenFunc > |
Loki::TL::IterateTypes< NullType, GenFunc > |
Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > |
Loki::Key< Factory, IdentifierType > |
Loki::TL::Length< NullType > |
Loki::TL::Length< Typelist< T, U > > |
std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > > |
std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > |
Loki::Private::LifetimeTracker |
LockableTwoRefCountInfo |
LockableTwoRefCounts |
Loki::LockedStorage< T > |
Loki::Locker< T > |
Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > |
Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 > |
Loki::TL::MakeTypelist<> |
Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > |
Loki::TL::MostDerived< NullType, T > |
Loki::TL::MostDerived< Typelist< Head, Tail >, T > |
Loki::Mutex |
Loki::TL::nameof_type< T > |
Loki::NeverCreate | Never allows creation. Testing purposes only
Loki::NeverCreate::Exception |
Loki::NeverReset< P > |
Loki::NoCheck< P > |
Loki::NoCopy< P > |
Loki::NoDestroy< T > |
Loki::TL::NoDuplicates< NullType > |
Loki::TL::NoDuplicates< Typelist< Head, Tail > > |
Loki::NoStatisticPolicy | Do nothing
Loki::NullPointerException |
Loki::NullType |
Loki::ObjScopeGuardImpl0< Obj, MemFun > |
Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > |
Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > |
Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > |
Loki::OpNewFactoryUnit< ConcreteProduct, Base > |
Loki::OrderedStatic< L, T, Loki::NullType > |
Loki::OrderedStatic< L, T, Loki::Seq< P1 > > |
Loki::OrderedStatic< L, T, P1(*)() > |
Loki::Private::OrderedStaticBase< T > |
Loki::Private::OrderedStaticCreatorFunc |
Loki::Private::OrderedStaticManagerClass |
Loki::PhoenixSingleton< T > |
Loki::Pimpl< T, Pointer > |
Loki::PimplOf< T, Ptr > |
PImplOf |
Loki::PimplOwner< T, Pointer > |
Loki::PrintfState< Device, Char > |
Loki::PropagateConst< T > |
Loki::PrototypeFactoryUnit< ConcreteProduct, Base > |
Loki::RateLimitedCreation | Limit in rate
Loki::RateLimitedCreation::Exception |
Loki::RefCounted< P > |
RefCountedMT |
Loki::RefCountedMTAdj< ThreadingModel, MX > |
Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > |
Loki::RefLinked< P > |
Loki::Private::RefLinkedBase |
Loki::RefToValue< T > |
Loki::Private::RegisterOnCreate< T > |
Loki::Private::RegisterOnCreateElement< T > |
Loki::RegisterOnCreateSet< ElementList > |
Loki::RejectNull< P > |
Loki::RejectNullStatic< P > |
Loki::RejectNullStrict< P > |
Loki::TL::Replace< NullType, T, U > |
Loki::TL::Replace< Typelist< Head, Tail >, T, U > |
Loki::TL::Replace< Typelist< T, Tail >, T, U > |
Loki::TL::ReplaceAll< NullType, T, U > |
Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U > |
Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U > |
Loki::TL::Reverse< NullType > |
Loki::TL::Reverse< Typelist< Head, Tail > > |
Loki::RimplOf< T, UsedPimpl > |
Loki::RimplOf< T, UsedPimpl >::Owner |
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::Select< flag, T, U > |
Loki::Select< false, T, U > |
Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > |
Loki::Seq<> |
Loki::SimplePointer< AbstractProduct > | No encaspulation : returns the pointer
Loki::SimpleStatisticPolicy | Simple statistics
Loki::SingleThreaded< Host, MutexPolicy > |
Loki::SingleThreaded< Host, MutexPolicy >::Lock |
Loki::Singleton< T > |
Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > |
Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > |
Loki::SingletonWithLongevity< T > |
Loki::TL::sizeof_type< T > |
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::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > |
Loki::StaticCaster< To, From > |
Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType > |
Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > |
Loki::SuperSubclass< T, U > |
Loki::SuperSubclass< T, void > |
Loki::SuperSubclass< void, U > |
Loki::SuperSubclass< void, void > |
Loki::SuperSubclassStrict< T, U > |
Loki::SuperSubclassStrict< T, void > |
Loki::SuperSubclassStrict< void, U > |
Loki::SuperSubclassStrict< void, void > |
Loki::Tuple< TList > |
Loki::TupleUnit< T > |
Loki::Private::TwoRefCountInfo |
Loki::TwoRefCounts |
Loki::TwoRefLinks |
Loki::Type2Type< T > |
Loki::TL::TypeAt< Typelist< Head, Tail >, 0 > |
Loki::TL::TypeAt< Typelist< Head, Tail >, i > |
Loki::TL::TypeAtNonStrict< TList, index, DefaultType > |
Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType > |
Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType > |
Loki::TypeInfo |
Loki::Typelist< T, U > |
Loki::TypeTraits< T > |
Loki::Private::UnRegisterOnDelete< T > |
Loki::Private::UnRegisterOnDeleteElement< T > |
Loki::UnRegisterOnDeleteSet< ElementList > |
Visitor |
Loki::Visitor< T, R, false > |
Loki::Visitor< T, R, true > |
Loki::Visitor< Typelist< Head, NullType >, R, false > |
Loki::Visitor< Typelist< Head, NullType >, R, true > |
Loki::Visitor< Typelist< Head, Tail >, R, false > |
Loki::Visitor< Typelist< Head, Tail >, R, true > |
Generated on Sat Jul 7 15:11:08 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AbstractFactory< TList, Unit > Class Template Reference

Loki::AbstractFactory

Loki::AbstractFactory< TList, Unit > Class Template Reference

Inheritance diagram for Loki::AbstractFactory< TList, Unit >:

[legend]
Collaboration diagram for Loki::AbstractFactory< TList, Unit >:

[legend]
List of all members.

Public Types

typedef TList | ProductList

Public Member Functions

template<class T>
T * | Create ()

Detailed Description

template<class TList, template< class > class Unit = AbstractFactoryUnit>
class Loki::AbstractFactory< TList, Unit >

Definition at line 67 of file AbstractFactory.h.

The documentation for this class was generated from the following file:
  • AbstractFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


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:
  • AbstractFactory.h
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AbstractFactoryUnit< T > Class Template Reference

Loki::AbstractFactoryUnit

Loki::AbstractFactoryUnit< T > Class Template Reference

List of all members.

Public Member Functions

virtual ~AbstractFactoryUnit ()

Detailed Description

template<class T>
class Loki::AbstractFactoryUnit< T >

Definition at line 50 of file AbstractFactory.h.

The documentation for this class was generated from the following file:
  • AbstractFactory.h
Generated on Sat Jul 7 15:11:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::Adapter< T > Struct Template Reference

Loki::Private::Adapter

Loki::Private::Adapter< T > Struct Template Reference

List of all members.

Public Member Functions

void operator() (T *)

Public Attributes

atexit_pfn_t pFun_

Detailed Description

template<class T>
struct Loki::Private::Adapter< T >

Definition at line 479 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddParameterType< U > Struct Template Reference

Loki::Private::AddParameterType

Loki::Private::AddParameterType< U > Struct Template Reference

List of all members.

Public Types

typedef const U & Result

Detailed Description

template<class U>
struct Loki::Private::AddParameterType< U >

Definition at line 140 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddParameterType< U & > Struct Template Reference

Loki::Private::AddParameterType< U & >

Loki::Private::AddParameterType< U & > Struct Template Reference

List of all members.

Public Types

typedef U & Result

Detailed Description

template<class U>
struct Loki::Private::AddParameterType< U & >

Definition at line 145 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddParameterType< void > Struct Template Reference

Loki::Private::AddParameterType< void >

Loki::Private::AddParameterType< void > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<>
struct Loki::Private::AddParameterType< void >

Definition at line 150 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddPointer< U > Struct Template Reference

Loki::Private::AddPointer

Loki::Private::AddPointer< U > Struct Template Reference

List of all members.

Public Types

typedef U * Result

Detailed Description

template<typename U>
struct Loki::Private::AddPointer< U >

Definition at line 115 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddPointer< U & > Struct Template Reference

Loki::Private::AddPointer< U & >

Loki::Private::AddPointer< U & > Struct Template Reference

List of all members.

Public Types

typedef U * Result

Detailed Description

template<typename U>
struct Loki::Private::AddPointer< U & >

Definition at line 120 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddReference< U > Struct Template Reference

Loki::Private::AddReference

Loki::Private::AddReference< U > Struct Template Reference

List of all members.

Public Types

typedef U & Result

Detailed Description

template<class U>
struct Loki::Private::AddReference< U >

Definition at line 125 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddReference< U & > Struct Template Reference

Loki::Private::AddReference< U & >

Loki::Private::AddReference< U & > Struct Template Reference

List of all members.

Public Types

typedef U & Result

Detailed Description

template<class U>
struct Loki::Private::AddReference< U & >

Definition at line 130 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AddReference< void > Struct Template Reference

Loki::Private::AddReference< void >

Loki::Private::AddReference< void > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<>
struct Loki::Private::AddReference< void >

Definition at line 135 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


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

Loki::AllocatorSingleton

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 AllocatorSingleton & | Instance (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.

Definition at line 222 of file SmallObj.h.

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

Definition at line 287 of file SmallObj.h.

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

Definition at line 303 of file SmallObj.h.

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:
  • SmallObj.h
Generated on Sat Jul 7 15:12:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AllowConversion Struct Reference

Loki::AllowConversion

Loki::AllowConversion Struct Reference
[Conversion policies]

#include <SmartPtr.h>

List of all members.

Public Types

enum

Public Member Functions

void Swap (AllowConversion &)

Detailed Description

Implementation of the ConversionPolicy used by SmartPtr Allows implicit conversion from SmartPtr to the pointee type

Definition at line 763 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AllowReset< P > Class Template Reference

Loki::AllowReset

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

#include <StrongPtr.h>

List of all members.

Public Member Functions

bool | OnReleaseAll (bool) const
bool | OnResetAll (bool) const

Detailed Description

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

Implementation of the ResetPolicy used by StrongPtr. It allows reset and release under any circumstance.

Definition at line 268 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AlwaysCreate Class Reference

Loki::AlwaysCreate

Loki::AlwaysCreate Class Reference
[Creation policies]

Always allows creation. More...

#include <CachedFactory.h>

List of all members.

Protected Member Functions

bool | canCreate ()
void | onCreate ()
void | onDestroy ()
const char * | name ()

Detailed Description

Always allows creation.

Doesn't limit the creation in any way

Definition at line 133 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AmountLimitedCreation Class Reference

Loki::AmountLimitedCreation

Loki::AmountLimitedCreation Class Reference
[Creation policies]

Limit by number of objects. More...

#include <CachedFactory.h>

List of all members.

Public Member Functions

void | setMaxCreation (unsigned maxCreation)

Protected Member Functions

AmountLimitedCreation ()
bool | canCreate ()
void | onCreate ()
void | onDestroy ()
const char * | name ()

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.

Definition at line 253 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Append< NullType, NullType > Struct Template Reference

Loki::TL::Append< NullType, NullType >

Loki::TL::Append< NullType, NullType > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<>
struct Loki::TL::Append< NullType, NullType >

Definition at line 208 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Append< NullType, T > Struct Template Reference

Loki::TL::Append< NullType, T >

Loki::TL::Append< NullType, T > Struct Template Reference

List of all members.

Public Types

typedef Typelist< T, NullType > Result

Detailed Description

template<class T>
struct Loki::TL::Append< NullType, T >

Definition at line 213 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Append< NullType, Typelist< Head, Tail > > Struct Template Reference

Loki::TL::Append< NullType, Typelist< Head, Tail > >

Loki::TL::Append< NullType, Typelist< Head, Tail > > Struct Template Reference

List of all members.

Public Types

typedef Typelist< Head, Tail > Result

Detailed Description

template<class Head, class Tail>
struct Loki::TL::Append< NullType, Typelist< Head, Tail > >

Definition at line 219 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Append< Typelist< Head, Tail >, T > Struct Template Reference

Loki::TL::Append< Typelist< Head, Tail >, T >

Loki::TL::Append< Typelist< Head, Tail >, T > Struct Template Reference

List of all members.

Public Types

typedef Typelist< Head, typename
Append< Tail, T >::Result > 		Result

Detailed Description

template<class Head, class Tail, class T>
struct Loki::TL::Append< Typelist< Head, Tail >, T >

Definition at line 225 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ArrayStorage< T > Class Template Reference

Loki::ArrayStorage

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

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * | StoredType
typedef T * | InitPointerType
typedef T * | PointerType
type used to declare OwnershipPolicy type.
typedef T & | ReferenceType

Public Member Functions

ArrayStorage ()
ArrayStorage (const ArrayStorage &)
template<class U>
ArrayStorage (const ArrayStorage< U > &)
ArrayStorage (const StoredType &p)
PointerType | operator-> () const
ReferenceType | operator * () const
void | Swap (ArrayStorage &rhs)

Protected Member Functions

void | Destroy ()

Static Protected Member Functions

static StoredType | Default ()

Detailed Description

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

Implementation of the ArrayStorage used by SmartPtr

Definition at line 353 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AssertCheck< P > Struct Template Reference

Loki::AssertCheck

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

#include <SmartPtr.h>

List of all members.

Public Member Functions

AssertCheck ()
template<class P1>
AssertCheck (const AssertCheck< P1 > &)
template<class P1>
AssertCheck (const NoCheck< P1 > &)

Static Public Member Functions

static void | OnDefault (const P &)
static void | OnInit (const P &)
static void | OnDereference (P val)
static void | Swap (AssertCheck &)

Detailed Description

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

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer before dereference

Definition at line 835 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AssertCheckStrict< P > Struct Template Reference

Loki::AssertCheckStrict

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

#include <SmartPtr.h>

List of all members.

Public Member Functions

AssertCheckStrict ()
template<class U>
AssertCheckStrict (const AssertCheckStrict< U > &)
template<class U>
AssertCheckStrict (const AssertCheck< U > &)
template<class P1>
AssertCheckStrict (const NoCheck< P1 > &)

Static Public Member Functions

static void | OnDefault (P val)
static void | OnInit (P val)
static void | OnDereference (P val)
static void | Swap (AssertCheckStrict &)

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

Definition at line 871 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AssocVector< K, V, C, A > Class Template Reference

Loki::AssocVector

Loki::AssocVector< K, V, C, A > Class Template Reference

Inheritance diagram for Loki::AssocVector< K, V, C, A >:

[legend]
Collaboration diagram for Loki::AssocVector< K, V, C, A >:

[legend]
List of all members.

Public Types

typedef K | key_type
typedef V | mapped_type
typedef Base::value_type | value_type
typedef C | key_compare
typedef A | allocator_type
typedef A::reference | reference
typedef A::const_reference | const_reference
typedef Base::iterator | iterator
typedef Base::const_iterator | const_iterator
typedef Base::size_type | size_type
typedef Base::difference_type | difference_type
typedef A::pointer | pointer
typedef A::const_pointer | const_pointer
typedef Base::reverse_iterator | reverse_iterator
typedef Base::const_reverse_iterator | const_reverse_iterator

Public Member Functions

AssocVector (const key_compare &comp=key_compare(), const A &alloc=A())
template<class InputIterator>
AssocVector (InputIterator first, InputIterator last, const key_compare &comp=key_compare(), const A &alloc=A())
AssocVector & | operator= (const AssocVector &rhs)
iterator begin ()
const_iterator | begin () const
iterator end ()
const_iterator | end () const
reverse_iterator rbegin ()
const_reverse_iterator | rbegin () const
reverse_iterator rend ()
const_reverse_iterator | rend () const
bool | empty () const
size_type | size () const
size_type max_size ()
mapped_type & | operator[] (const key_type &key)
std::pair< iterator, bool > | insert (const value_type &val)
iterator | insert (iterator pos, const value_type &val)
template<class InputIterator>
void | insert (InputIterator first, InputIterator last)
void | erase (iterator pos)
size_type | erase (const key_type &k)
void | erase (iterator first, iterator last)
void | swap (AssocVector &other)
void | clear ()
key_compare | key_comp () const
value_compare | value_comp () const
iterator | find (const key_type &k)
const_iterator | find (const key_type &k) const
size_type | count (const key_type &k) const
iterator | lower_bound (const key_type &k)
const_iterator | lower_bound (const key_type &k) const
iterator | upper_bound (const key_type &k)
const_iterator | upper_bound (const key_type &k) const
std::pair< iterator, iterator > | equal_range (const key_type &k)
std::pair< const_iterator,
const_iterator > 		equal_range (const key_type &k) const
bool | operator< (const AssocVector &rhs) const

Classes

class | value_compare

Detailed Description

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >>
class Loki::AssocVector< K, V, C, A >

Definition at line 85 of file AssocVector.h.

The documentation for this class was generated from the following file:
  • AssocVector.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::AssocVector< K, V, C, A >::value_compare Class Reference

Loki::AssocVector::value_compare

Loki::AssocVector< K, V, C, A >::value_compare Class Reference

List of all members.

Public Member Functions

bool | operator() (const value_type &lhs, const value_type &rhs) const

Protected Member Functions

value_compare (key_compare pred)

Friends

class | AssocVector

Detailed Description

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >>
class Loki::AssocVector< K, V, C, A >::value_compare

Definition at line 110 of file AssocVector.h.

The documentation for this class was generated from the following file:
  • AssocVector.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::AssocVectorCompare< Value, C > Class Template Reference

Loki::Private::AssocVectorCompare

Loki::Private::AssocVectorCompare< Value, C > Class Template Reference

Inheritance diagram for Loki::Private::AssocVectorCompare< Value, C >:

[legend]
List of all members.

Public Member Functions

AssocVectorCompare ()
AssocVectorCompare (const C &src)
bool | operator() (const first_argument_type &lhs, const first_argument_type &rhs) const
bool | operator() (const Data &lhs, const Data &rhs) const
bool | operator() (const Data &lhs, const first_argument_type &rhs) const
bool | operator() (const first_argument_type &lhs, const Data &rhs) const

Detailed Description

template<class Value, class C>
class Loki::Private::AssocVectorCompare< Value, C >

Definition at line 36 of file AssocVector.h.

The documentation for this class was generated from the following file:
  • AssocVector.h
Generated on Sat Jul 7 15:12:36 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::BaseVisitable< R, CatchAll, false > Class Template Reference

Loki::BaseVisitable< R, CatchAll, false >

Loki::BaseVisitable< R, CatchAll, false > Class Template Reference

List of all members.

Public Types

typedef R | ReturnType

Public Member Functions

virtual | ~BaseVisitable ()

Static Protected Member Functions

template<class T>
static ReturnType | AcceptImpl (T &visited, BaseVisitor &guest)

Detailed Description

template<typename R, template< typename, class > class CatchAll>
class Loki::BaseVisitable< R, CatchAll, false >

Definition at line 253 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::BaseVisitable< R, CatchAll, true > Class Template Reference

Loki::BaseVisitable< R, CatchAll, true >

Loki::BaseVisitable< R, CatchAll, true > Class Template Reference

List of all members.

Public Types

typedef R | ReturnType

Public Member Functions

virtual | ~BaseVisitable ()

Static Protected Member Functions

template<class T>
static ReturnType | AcceptImpl (const T &visited, BaseVisitor &guest)

Detailed Description

template<typename R, template< typename, class > class CatchAll>
class Loki::BaseVisitable< R, CatchAll, true >

Definition at line 274 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::BaseVisitor Class Reference

Loki::BaseVisitor

Loki::BaseVisitor Class Reference
[Visitor]

#include <Visitor.h>

List of all members.

Public Member Functions

virtual ~BaseVisitor ()

Detailed Description

The base class of any Acyclic Visitor

Definition at line 36 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::BaseVisitorImpl< Typelist< Head, NullType >, R > Class Template Reference

Loki::BaseVisitorImpl< Typelist< Head, NullType >, R >

Loki::BaseVisitorImpl< Typelist< Head, NullType >, R > Class Template Reference

Inheritance diagram for Loki::BaseVisitorImpl< Typelist< Head, NullType >, R >:

[legend]
Collaboration diagram for Loki::BaseVisitorImpl< Typelist< Head, NullType >, R >:

[legend]
List of all members.

Public Member Functions

virtual R Visit (Head &)

Detailed Description

template<class Head, typename R>
class Loki::BaseVisitorImpl< Typelist< Head, NullType >, R >

Definition at line 221 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::BaseVisitorImpl< Typelist< Head, Tail >, R > Class Template Reference

Loki::BaseVisitorImpl< Typelist< Head, Tail >, R >

Loki::BaseVisitorImpl< Typelist< Head, Tail >, R > Class Template Reference

Inheritance diagram for Loki::BaseVisitorImpl< Typelist< Head, Tail >, R >:

[legend]
Collaboration diagram for Loki::BaseVisitorImpl< Typelist< Head, Tail >, R >:

[legend]
List of all members.

Public Member Functions

virtual R Visit (Head &)

Detailed Description

template<class Head, class Tail, typename R>
class Loki::BaseVisitorImpl< Typelist< Head, Tail >, R >

Definition at line 209 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > Class Template Reference

Loki::BasicDispatcher

Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > Class Template Reference

Collaboration diagram for Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType >:

[legend]
List of all members.

Public Member Functions

template<class SomeLhs, class SomeRhs>
void | Add (CallbackType fun)
template<class SomeLhs, class SomeRhs>
bool | Remove ()
ResultType | Go (BaseLhs &lhs, BaseRhs &rhs)

Detailed Description

template<class BaseLhs, class BaseRhs = BaseLhs, typename ResultType = void, typename CallbackType = ResultType (*)(BaseLhs&, BaseRhs&)>
class Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType >

Definition at line 134 of file MultiMethods.h.

The documentation for this class was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::BinderFirst< OriginalFunctor > Class Template Reference

Loki::BinderFirst

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

#include <Functor.h>

List of all members.

Public Member Functions

BinderFirst (const OriginalFunctor &fun, BoundType bound)
virtual BinderFirst * | DoClone () const
ResultType | operator() ()
ResultType | operator() (Parm1 p1)
ResultType | operator() (Parm1 p1, Parm2 p2)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)

Detailed Description

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

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

Definition at line 1487 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::BinderFirstBoundTypeStorage< T > Struct Template Reference

Loki::Private::BinderFirstBoundTypeStorage

Loki::Private::BinderFirstBoundTypeStorage< T > Struct Template Reference

List of all members.

Public Types

typedef TypeTraits< T >::ParameterType RefOrValue

Detailed Description

template<class T>
struct Loki::Private::BinderFirstBoundTypeStorage< T >

Definition at line 1464 of file Functor.h.

The documentation for this struct was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > > Struct Template Reference

Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > >

Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > > Struct Template Reference

List of all members.

Public Types

typedef Functor< R, TList,
ThreadingModel > 		OriginalFunctor
typedef const TypeTraits<
OriginalFunctor >::ReferredType 		RefOrValue

Detailed Description

template<typename R, class TList, template< class, class > class ThreadingModel>
struct Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > >

Definition at line 1470 of file Functor.h.

The documentation for this struct was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > > Struct Template Reference

Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >

Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > > Struct Template Reference

List of all members.

Public Types

typedef Functor< R, TList,
ThreadingModel > 		OriginalFunctor
typedef TL::Erase< TList,
typename TL::TypeAt< TList,
0 >::Result >::Result 		ParmList
typedef TL::TypeAt< TList,
0 >::Result 		OriginalParm1
typedef Functor< R, ParmList,
ThreadingModel > 		BoundFunctorType
typedef BoundFunctorType::Impl Impl

Detailed Description

template<typename R, class TList, template< class, class > class ThreadingModel>
struct Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >

Definition at line 1443 of file Functor.h.

The documentation for this struct was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


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

Loki::CachedFactory

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

Factory with caching support. More...

#include <CachedFactory.h>

Collaboration diagram for Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >:

[legend]
List of all members.

Public Types

typedef NP::ProductReturn | ProductReturn

Public Member Functions

CachedFactory ()
~CachedFactory ()
bool | Register (const IdentifierType &id, ProductCreator creator)
template<class PtrObj, typename CreaFn>
bool | Register (const IdentifierType &id, const PtrObj &p, CreaFn fn)
bool | Unregister (const IdentifierType &id)
std::vector< IdentifierType > & | RegisteredIds ()
Return the registered ID in this Factory.
ProductReturn | CreateObject (const IdentifierType &id)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
ProductReturn | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
void | ReleaseObject (ProductReturn &object)
Use this function to release the object.
void | displayCacheType ()
display the cache configuration

Protected Member Functions

virtual void | remove (AbstractProduct *const pProduct)

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.

Definition at line 660 of file CachedFactory.h.

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 :-)

Definition at line 1140 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CacheException Class Reference

Loki::CacheException

Loki::CacheException Class Reference

List of all members.

Public Member Functions

const char * what () const throw ()

Detailed Description

Definition at line 631 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CantResetWithStrong< P > Class Template Reference

Loki::CantResetWithStrong

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

#include <StrongPtr.h>

List of all members.

Public Member Functions

bool | OnReleaseAll (bool hasStrongPtr) const
bool | OnResetAll (bool hasStrongPtr) const

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.

Definition at line 246 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Chainer< Fun1, Fun2 > Class Template Reference

Loki::Chainer

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

#include <Functor.h>

List of all members.

Public Types

typedef Base::ResultType | ResultType
typedef Base::Parm1 | Parm1
typedef Base::Parm2 | Parm2
typedef Base::Parm3 | Parm3
typedef Base::Parm4 | Parm4
typedef Base::Parm5 | Parm5
typedef Base::Parm6 | Parm6
typedef Base::Parm7 | Parm7
typedef Base::Parm8 | Parm8
typedef Base::Parm9 | Parm9
typedef Base::Parm10 | Parm10
typedef Base::Parm11 | Parm11
typedef Base::Parm12 | Parm12
typedef Base::Parm13 | Parm13
typedef Base::Parm14 | Parm14
typedef Base::Parm15 | Parm15

Public Member Functions

Chainer (const Fun1 &fun1, const Fun2 &fun2)
virtual Chainer * | DoClone () const
ResultType operator() ()
ResultType | operator() (Parm1 p1)
ResultType | operator() (Parm1 p1, Parm2 p2)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)

Detailed Description

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

Chains two functor calls one after another

Definition at line 1631 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Chunk Struct Reference

Loki::Chunk

Loki::Chunk Struct Reference
[Internals]

List of all members.

Friends

class FixedAllocator

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.

Definition at line 68 of file SmallObj.cpp.

The documentation for this struct was generated from the following file:
  • SmallObj.cpp
Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > Class Template Reference

Loki::CloneFactory

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

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

#include <Factory.h>

Collaboration diagram for Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >:

[legend]
List of all members.

Public Member Functions

bool | Register (const TypeInfo &ti, ProductCreator creator)
bool | Unregister (const TypeInfo &id)
AbstractProduct * | CreateObject (const AbstractProduct *model)

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.

Definition at line 1039 of file Factory.h.

The documentation for this class was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CompileTimeError< true > Struct Template Reference

Loki::CompileTimeError< true >

Loki::CompileTimeError< true > Struct Template Reference

Detailed Description

template<>
struct Loki::CompileTimeError< true >

Definition at line 28 of file static_check.h.

The documentation for this struct was generated from the following file:
  • static_check.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::COMRefCounted< P > Class Template Reference

Loki::COMRefCounted

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

#include <SmartPtr.h>

List of all members.

Public Types

enum

Public Member Functions

COMRefCounted ()
template<class U>
COMRefCounted (const COMRefCounted< U > &)

Static Public Member Functions

static P | Clone (const P &val)
static bool | Release (const P &val)
static void | Swap (COMRefCounted &)

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

Definition at line 560 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ConcreteFactory< AbstractFact, Creator, TList > Class Template Reference

Loki::ConcreteFactory

Loki::ConcreteFactory< AbstractFact, Creator, TList > Class Template Reference

List of all members.

Public Types

typedef AbstractFact::ProductList | ProductList
typedef TList | ConcreteProductList

Detailed Description

template<class AbstractFact, template< class, class > class Creator = OpNewFactoryUnit, class TList = typename AbstractFact::ProductList>
class Loki::ConcreteFactory< AbstractFact, Creator, TList >

Definition at line 172 of file AbstractFactory.h.

The documentation for this class was generated from the following file:
  • AbstractFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::ConcreteLifetimeTracker< T, Destroyer > Class Template Reference

Loki::Private::ConcreteLifetimeTracker

Loki::Private::ConcreteLifetimeTracker< T, Destroyer > Class Template Reference

Inheritance diagram for Loki::Private::ConcreteLifetimeTracker< T, Destroyer >:

[legend]
Collaboration diagram for Loki::Private::ConcreteLifetimeTracker< T, Destroyer >:

[legend]
List of all members.

Public Member Functions

ConcreteLifetimeTracker (T *p, unsigned int longevity, Destroyer d)
~ConcreteLifetimeTracker ()

Detailed Description

template<typename T, typename Destroyer>
class Loki::Private::ConcreteLifetimeTracker< T, Destroyer >

Definition at line 119 of file Singleton.h.

The documentation for this class was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ConstPropPtr< T > Class Template Reference

Loki::ConstPropPtr

Loki::ConstPropPtr< T > Class Template Reference
[Pimpl]

#include <Pimpl.h>

List of all members.

Public Member Functions

ConstPropPtr (T *p)
~ConstPropPtr ()
T * | operator-> ()
T & | operator * ()
const T * | operator-> () const
const T & | operator * () const

Detailed Description

template<class T>
class Loki::ConstPropPtr< T >

Simple const propagating smart pointer Is the default smart pointer of Pimpl.

Definition at line 40 of file Pimpl.h.

The documentation for this class was generated from the following file:
  • Pimpl.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Conversion< T, U > Struct Template Reference

Loki::Conversion

Loki::Conversion< T, U > Struct Template Reference

List of all members.

Public Types

enum
enum
enum
typedef Private::ConversionHelper<
T, U > 		H

Detailed Description

template<class T, class U>
struct Loki::Conversion< T, U >

Definition at line 125 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Conversion< T, T > Struct Template Reference

Loki::Conversion< T, T >

Loki::Conversion< T, T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<class T>
struct Loki::Conversion< T, T >

Definition at line 138 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Conversion< T, void > Struct Template Reference

Loki::Conversion< T, void >

Loki::Conversion< T, void > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<class T>
struct Loki::Conversion< T, void >

Definition at line 150 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Conversion< void, T > Struct Template Reference

Loki::Conversion< void, T >

Loki::Conversion< void, T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<class T>
struct Loki::Conversion< void, T >

Definition at line 144 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Conversion< void, void > Struct Template Reference

Loki::Conversion< void, void >

Loki::Conversion< void, void > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<>
struct Loki::Conversion< void, void >

Definition at line 156 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::ConversionHelper< T, U > Struct Template Reference

Loki::Private::ConversionHelper

Loki::Private::ConversionHelper< T, U > Struct Template Reference

List of all members.

Public Types

typedef char | Small

Classes

struct | Big

Detailed Description

template<class T, class U>
struct Loki::Private::ConversionHelper< T, U >

Definition at line 98 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::ConversionHelper< T, U >::Big Struct Reference

Loki::Private::ConversionHelper::Big

Loki::Private::ConversionHelper< T, U >::Big Struct Reference

List of all members.

Public Attributes

char dummy [2]

Detailed Description

template<class T, class U>
struct Loki::Private::ConversionHelper< T, U >::Big

Definition at line 101 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CreateStatic< T > Struct Template Reference

Loki::CreateStatic

Loki::CreateStatic< T > Struct Template Reference
[Creation policies]

#include <Singleton.h>

List of all members.

Static Public Member Functions

static T * | Create ()
static void | Destroy (T *p)

Classes

union | MaxAlign

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.

Definition at line 304 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CreateStatic< T >::MaxAlign Union Reference

Loki::CreateStatic::MaxAlign

Loki::CreateStatic< T >::MaxAlign Union Reference

List of all members.

Public Attributes

char | t_ [sizeof(T)]
short int | shortInt_
int | int_
long int | longInt_
float | float_
double | double_
long double | longDouble_
int Test::* | pMember_

Detailed Description

template<class T>
union Loki::CreateStatic< T >::MaxAlign

Definition at line 313 of file Singleton.h.

The documentation for this union was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CreateUsing< Alloc > Struct Template Reference

Loki::CreateUsing

Loki::CreateUsing< Alloc > Struct Template Reference
[Creation policies]

#include <Singleton.h>

Classes

struct Allocator

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

Definition at line 248 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CreateUsing< Alloc >::Allocator< T > Struct Template Reference

Loki::CreateUsing::Allocator

Loki::CreateUsing< Alloc >::Allocator< T > Struct Template Reference

List of all members.

Static Public Member Functions

static T * | Create ()
static void | Destroy (T *p)

Static Public Attributes

static Alloc< T > | allocator

Detailed Description

template<template< class > class Alloc>
template<class T>
struct Loki::CreateUsing< Alloc >::Allocator< T >

Definition at line 251 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CreateUsingMalloc< T > Struct Template Reference

Loki::CreateUsingMalloc

Loki::CreateUsingMalloc< T > Struct Template Reference
[Creation policies]

#include <Singleton.h>

List of all members.

Static Public Member Functions

static T * | Create ()
static void | Destroy (T *p)

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

Definition at line 277 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CreateUsingNew< T > Struct Template Reference

Loki::CreateUsingNew

Loki::CreateUsingNew< T > Struct Template Reference
[Creation policies]

#include <Singleton.h>

List of all members.

Static Public Member Functions

static T * | Create ()
static void | Destroy (T *p)

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

Definition at line 230 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::CyclicVisitor< R, TList > Class Template Reference

Loki::CyclicVisitor

Loki::CyclicVisitor< R, TList > Class Template Reference
[Visitor]

#include <Visitor.h>

Inheritance diagram for Loki::CyclicVisitor< R, TList >:

[legend]
Collaboration diagram for Loki::CyclicVisitor< R, TList >:

[legend]
List of all members.

Public Types

typedef R | ReturnType

Public Member Functions

template<class Visited>
ReturnType | GenericVisit (Visited &host)

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>

Definition at line 326 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DeepCopy< P > Struct Template Reference

Loki::DeepCopy

Loki::DeepCopy< P > Struct Template Reference
[Ownership policies]

#include <SmartPtr.h>

List of all members.

Public Types

enum

Public Member Functions

DeepCopy ()
template<class P1>
DeepCopy (const DeepCopy< P1 > &)

Static Public Member Functions

static P | Clone (const P &val)
static bool | Release (const P &)
static void | Swap (DeepCopy &)

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

Definition at line 600 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DefaultCatchAll< R, Visited > Struct Template Reference

Loki::DefaultCatchAll

Loki::DefaultCatchAll< R, Visited > Struct Template Reference

List of all members.

Static Public Member Functions

static R OnUnknownVisitor (Visited &, BaseVisitor &)

Detailed Description

template<typename R, typename Visited>
struct Loki::DefaultCatchAll< R, Visited >

Definition at line 234 of file Visitor.h.

The documentation for this struct was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:20 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DefaultFactoryError< IdentifierType, AbstractProduct > Class Template Reference

Loki::DefaultFactoryError

Loki::DefaultFactoryError< IdentifierType, AbstractProduct > Class Template Reference
[Factory Error Policies]

Default policy that throws an exception. More...

#include <Factory.h>

List of all members.

Static Public Member Functions

static AbstractProduct * | OnUnknownType (IdentifierType)

Classes

struct | Exception

Detailed Description

template<typename IdentifierType, class AbstractProduct>
class Loki::DefaultFactoryError< IdentifierType, AbstractProduct >

Default policy that throws an exception.

Definition at line 91 of file Factory.h.

The documentation for this class was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception Struct Reference

Loki::DefaultFactoryError::Exception

Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception Struct Reference

List of all members.

Public Member Functions

const char * what () const throw ()

Detailed Description

template<typename IdentifierType, class AbstractProduct>
struct Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception

Definition at line 93 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DefaultLifetime< T > Struct Template Reference

Loki::DefaultLifetime

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

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void | ScheduleDestruction (T *, atexit_pfn_t pFun)
static void | OnDeadReference ()

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

Definition at line 352 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DefaultSPStorage< T > Class Template Reference

Loki::DefaultSPStorage

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

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * | StoredType
typedef T * | InitPointerType
typedef T * | PointerType
type used to declare OwnershipPolicy type.
typedef T & | ReferenceType

Public Member Functions

DefaultSPStorage ()
DefaultSPStorage (const DefaultSPStorage &)
template<class U>
DefaultSPStorage (const DefaultSPStorage< U > &)
DefaultSPStorage (const StoredType &p)
PointerType | operator-> () const
ReferenceType | operator * () const
void | Swap (DefaultSPStorage &rhs)

Protected Member Functions

void | Destroy ()

Static Protected Member Functions

static StoredType | Default ()

Detailed Description

template<class T>
class Loki::DefaultSPStorage< T >

Implementation of the StoragePolicy used by SmartPtr

Definition at line 149 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DeletableSingleton< T > Struct Template Reference

Loki::DeletableSingleton

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

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void | ScheduleDestruction (T *, atexit_pfn_t pFun)
static void | OnDeadReference ()
static void | GracefulDelete ()
delete singleton object manually

Static Protected Member Functions

static void | atexitCallback ()

Static Protected Attributes

static atexit_pfn_t | deleter
static bool | isDead
static bool | needCallback

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();

Definition at line 417 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DeleteArray< P > Class Template Reference

Loki::DeleteArray

Loki::DeleteArray< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.

Public Member Functions

void | Swap (DeleteArray &)

Static Public Member Functions

static void | Delete (const P *p)
static P * | Default (void)

Detailed Description

template<class P>
class Loki::DeleteArray< P >

Implementation of the DeletePolicy used by StrongPtr. This deletes an array of shared objects.

Definition at line 214 of file StrongPtr.h.

Member Function Documentation

template<class P>
static void Loki::DeleteArray< P >::Delete ( const P * p ) [inline, static]

Definition at line 217 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DeleteNothing< P > Class Template Reference

Loki::DeleteNothing

Loki::DeleteNothing< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.

Public Member Functions

void | Swap (DeleteNothing &)

Static Public Member Functions

static void | Delete (const P *)
static P * | Default (void)

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.

Definition at line 158 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::Deleter< T > Struct Template Reference

Loki::Private::Deleter

Loki::Private::Deleter< T > Struct Template Reference

List of all members.

Public Types

typedef void(*) | Type (T *)

Static Public Member Functions

static void | Delete (T *pObj)

Detailed Description

template<typename T>
struct Loki::Private::Deleter< T >

Definition at line 110 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DeleteSingle< P > Class Template Reference

Loki::DeleteSingle

Loki::DeleteSingle< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.

Public Member Functions

void | Swap (DeleteSingle &)

Static Public Member Functions

static void | Delete (const P *p)
static P * | Default (void)

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.

Definition at line 183 of file StrongPtr.h.

Member Function Documentation

template<class P>
static void Loki::DeleteSingle< P >::Delete ( const P * p ) [inline, static]

Definition at line 186 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DeleteUsingFree< P > Class Template Reference

Loki::DeleteUsingFree

Loki::DeleteUsingFree< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.

Public Member Functions

void | Swap (DeleteUsingFree &)

Static Public Member Functions

static void | Delete (const P *p)
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.

Definition at line 127 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::DerivedToFront< NullType > Struct Template Reference

Loki::TL::DerivedToFront< NullType >

Loki::TL::DerivedToFront< NullType > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<>
struct Loki::TL::DerivedToFront< NullType >

Definition at line 436 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::DerivedToFront< Typelist< Head, Tail > > Struct Template Reference

Loki::TL::DerivedToFront< Typelist< Head, Tail > >

Loki::TL::DerivedToFront< Typelist< Head, Tail > > Struct Template Reference

List of all members.

Public Types

typedef Typelist< TheMostDerived,
L > 		Result

Detailed Description

template<class Head, class Tail>
struct Loki::TL::DerivedToFront< Typelist< Head, Tail > >

Definition at line 442 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DestructiveCopy< P > Class Template Reference

Loki::DestructiveCopy

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

#include <SmartPtr.h>

List of all members.

Public Types

enum

Public Member Functions

DestructiveCopy ()
template<class P1>
DestructiveCopy (const DestructiveCopy< P1 > &)

Static Public Member Functions

template<class P1>
static P | Clone (P1 &val)
static bool | Release (const P &)
static void | Swap (DestructiveCopy &)

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)

Definition at line 692 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::LongevityLifetime::DieAsSmallObjectChild< T > Struct Template Reference

Loki::LongevityLifetime::DieAsSmallObjectChild

Loki::LongevityLifetime::DieAsSmallObjectChild< T > Struct Template Reference
[Small objects]

#include <SmallObj.h>

Inheritance diagram for Loki::LongevityLifetime::DieAsSmallObjectChild< T >:

[legend]
Collaboration diagram for Loki::LongevityLifetime::DieAsSmallObjectChild< T >:

[legend]

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

Definition at line 74 of file SmallObj.h.

The documentation for this struct was generated from the following file:
  • SmallObj.h
Generated on Sat Jul 7 15:12:35 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::LongevityLifetime::DieAsSmallObjectParent< T > Struct Template Reference

Loki::LongevityLifetime::DieAsSmallObjectParent

Loki::LongevityLifetime::DieAsSmallObjectParent< T > Struct Template Reference
[Small objects]

#include <SmallObj.h>

Inheritance diagram for Loki::LongevityLifetime::DieAsSmallObjectParent< T >:

[legend]
Collaboration diagram for Loki::LongevityLifetime::DieAsSmallObjectParent< T >:

[legend]

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

Definition at line 65 of file SmallObj.h.

The documentation for this struct was generated from the following file:
  • SmallObj.h
Generated on Sat Jul 7 15:12:35 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::LongevityLifetime::DieDirectlyBeforeLast< T > Struct Template Reference

Loki::LongevityLifetime::DieDirectlyBeforeLast

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

[legend]
Collaboration diagram for Loki::LongevityLifetime::DieDirectlyBeforeLast< T >:

[legend]

Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieDirectlyBeforeLast< T >

Lifetime is a one less than DieLast: 0xFFFFFFFF-1.

Definition at line 576 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:34 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::LongevityLifetime::DieFirst< T > Struct Template Reference

Loki::LongevityLifetime::DieFirst

Loki::LongevityLifetime::DieFirst< T > Struct Template Reference
[LongevityLifetime]

Shortest possible SingletonWithLongevity lifetime: 0. More...

#include <Singleton.h>

Inheritance diagram for Loki::LongevityLifetime::DieFirst< T >:

[legend]
Collaboration diagram for Loki::LongevityLifetime::DieFirst< T >:

[legend]

Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieFirst< T >

Shortest possible SingletonWithLongevity lifetime: 0.

Definition at line 583 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:35 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::LongevityLifetime::DieLast< T > Struct Template Reference

Loki::LongevityLifetime::DieLast

Loki::LongevityLifetime::DieLast< T > Struct Template Reference
[LongevityLifetime]

Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF. More...

#include <Singleton.h>

Inheritance diagram for Loki::LongevityLifetime::DieLast< T >:

[legend]
Collaboration diagram for Loki::LongevityLifetime::DieLast< T >:

[legend]

Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieLast< T >

Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF.

Definition at line 569 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:34 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DisallowConversion Struct Reference

Loki::DisallowConversion

Loki::DisallowConversion Struct Reference
[Conversion policies]

#include <SmartPtr.h>

List of all members.

Public Types

enum

Public Member Functions

DisallowConversion ()
DisallowConversion (const AllowConversion &)
void Swap (DisallowConversion &)

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

Definition at line 780 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DontPropagateConst< T > Class Template Reference

Loki::DontPropagateConst

Loki::DontPropagateConst< T > Class Template Reference

#include <ConstPolicy.h>

List of all members.

Public Types

typedef T Type

Detailed Description

template<class T>
class Loki::DontPropagateConst< T >

Don't propagate constness of pointed or referred object.

Definition at line 36 of file ConstPolicy.h.

The documentation for this class was generated from the following file:
  • ConstPolicy.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::DynamicCaster< To, From > Struct Template Reference

Loki::DynamicCaster

Loki::DynamicCaster< To, From > Struct Template Reference

List of all members.

Static Public Member Functions

static To & Cast (From &obj)

Detailed Description

template<class To, class From>
struct Loki::DynamicCaster< To, From >

Definition at line 211 of file MultiMethods.h.

The documentation for this struct was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::EmptyType Class Reference

Loki::EmptyType

Loki::EmptyType Class Reference

Detailed Description

Definition at line 29 of file EmptyType.h.

The documentation for this class was generated from the following file:
  • EmptyType.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Erase< NullType, T > Struct Template Reference

Loki::TL::Erase< NullType, T >

Loki::TL::Erase< NullType, T > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<class T>
struct Loki::TL::Erase< NullType, T >

Definition at line 243 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Erase< Typelist< Head, Tail >, T > Struct Template Reference

Loki::TL::Erase< Typelist< Head, Tail >, T >

Loki::TL::Erase< Typelist< Head, Tail >, T > Struct Template Reference

List of all members.

Public Types

typedef Typelist< Head, typename
Erase< Tail, T >::Result > 		Result

Detailed Description

template<class Head, class Tail, class T>
struct Loki::TL::Erase< Typelist< Head, Tail >, T >

Definition at line 255 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Erase< Typelist< T, Tail >, T > Struct Template Reference

Loki::TL::Erase< Typelist< T, Tail >, T >

Loki::TL::Erase< Typelist< T, Tail >, T > Struct Template Reference

List of all members.

Public Types

typedef Tail Result

Detailed Description

template<class T, class Tail>
struct Loki::TL::Erase< Typelist< T, Tail >, T >

Definition at line 249 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::EraseAll< NullType, T > Struct Template Reference

Loki::TL::EraseAll< NullType, T >

Loki::TL::EraseAll< NullType, T > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<class T>
struct Loki::TL::EraseAll< NullType, T >

Definition at line 272 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::EraseAll< Typelist< Head, Tail >, T > Struct Template Reference

Loki::TL::EraseAll< Typelist< Head, Tail >, T >

Loki::TL::EraseAll< Typelist< Head, Tail >, T > Struct Template Reference

List of all members.

Public Types

typedef Typelist< Head, typename
EraseAll< Tail, T >::Result > 		Result

Detailed Description

template<class Head, class Tail, class T>
struct Loki::TL::EraseAll< Typelist< Head, Tail >, T >

Definition at line 283 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::EraseAll< Typelist< T, Tail >, T > Struct Template Reference

Loki::TL::EraseAll< Typelist< T, Tail >, T >

Loki::TL::EraseAll< Typelist< T, Tail >, T > Struct Template Reference

List of all members.

Public Types

typedef EraseAll< Tail, T
>::Result 		Result

Detailed Description

template<class T, class Tail>
struct Loki::TL::EraseAll< Typelist< T, Tail >, T >

Definition at line 277 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::EvictAging< DT, ST > Class Template Reference

Loki::EvictAging

Loki::EvictAging< DT, ST > Class Template Reference
[Eviction policies]

LRU aware of the time span of use. More...

#include <CachedFactory.h>

Inheritance diagram for Loki::EvictAging< DT, ST >:

[legend]
Collaboration diagram for Loki::EvictAging< DT, ST >:

[legend]
List of all members.

Protected Member Functions

EvictAging ()
virtual | ~EvictAging ()
void | onCreate (const DT &key)
void | onFetch (const DT &)
void | onRelease (const DT &key)
void | onDestroy (const DT &key)
void | evict ()
const char * | name ()

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

Definition at line 409 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::EvictionException Class Reference

Loki::EvictionException

Loki::EvictionException Class Reference

List of all members.

Public Member Functions

const char * what () const throw ()

Detailed Description

Definition at line 295 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::EvictionHelper< ST, DT > Class Template Reference

Loki::EvictionHelper

Loki::EvictionHelper< ST, DT > Class Template Reference

Inheritance diagram for Loki::EvictionHelper< ST, DT >:

[legend]
List of all members.

Protected Types

typedef std::map< DT, ST > | HitMap
typedef HitMap::iterator | HitMapItr

Protected Member Functions

DT & | getLowerBound ()

Protected Attributes

HitMap m_mHitCount

Detailed Description

template<typename ST, typename DT>
class Loki::EvictionHelper< ST, DT >

Definition at line 308 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::EvictLRU< DT, ST > Class Template Reference

Loki::EvictLRU

Loki::EvictLRU< DT, ST > Class Template Reference
[Eviction policies]

Evicts least accessed objects first. More...

#include <CachedFactory.h>

Inheritance diagram for Loki::EvictLRU< DT, ST >:

[legend]
Collaboration diagram for Loki::EvictLRU< DT, ST >:

[legend]
List of all members.

Protected Member Functions

virtual | ~EvictLRU ()
void | onCreate (const DT &key)
void | onFetch (const DT &)
void | onRelease (const DT &key)
void | onDestroy (const DT &key)
void | evict ()
const char * | name ()

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.

Definition at line 351 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::EvictRandom< DT, ST > Class Template Reference

Loki::EvictRandom

Loki::EvictRandom< DT, ST > Class Template Reference
[Eviction policies]

Evicts a random object. More...

#include <CachedFactory.h>

List of all members.

Protected Member Functions

virtual | ~EvictRandom ()
void | onCreate (const DT &)
void | onFetch (const DT &)
void | onRelease (const DT &key)
void | onDestroy (const DT &key)
void | evict ()
const char * | name ()

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 .

Definition at line 485 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > Class Template Reference

Loki::Factory

Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > Class Template Reference
[Factory]

#include <Factory.h>

Collaboration diagram for Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >:

[legend]
List of all members.

Public Member Functions

Factory ()
~Factory ()
bool | Register (const IdentifierType &id, ProductCreator creator)
template<class PtrObj, typename CreaFn>
bool | Register (const IdentifierType &id, const PtrObj &p, CreaFn fn)
bool | Unregister (const IdentifierType &id)
std::vector< IdentifierType > | RegisteredIds ()
AbstractProduct * | CreateObject (const IdentifierType &id)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
AbstractProduct * | CreateObject (const IdentifierType &id, Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)

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
 Loki::LongevityLifetime::DieAsSmallObjectChild
Alternatively you could suppress for Functor the inheritance from SmallObject by defining the macro:
 LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT

Definition at line 752 of file Factory.h.

The documentation for this class was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, NullType > Struct Template Reference

Loki::FactoryImpl< AP, Id, NullType >

Loki::FactoryImpl< AP, Id, NullType > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, NullType >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, NullType >:

[legend]
List of all members.

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id>
struct Loki::FactoryImpl< AP, Id, NullType >

Definition at line 136 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1 > >

Loki::FactoryImpl< AP, Id, Seq< P1 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1>
struct Loki::FactoryImpl< AP, Id, Seq< P1 > >

Definition at line 143 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2 > >

Definition at line 152 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > >

Definition at line 162 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > >

Definition at line 173 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > >

Definition at line 186 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > >

Definition at line 201 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > >

Definition at line 219 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > >

Definition at line 238 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > >

Definition at line 258 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > >

Definition at line 279 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > >

Definition at line 302 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > >

Definition at line 327 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:48 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > >

Definition at line 353 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >

Definition at line 380 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > Struct Template Reference

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > >

Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > >:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > >:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14
typedef TypeTraits< P15
>::ParameterType 		Parm15

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > >

Definition at line 408 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:49 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> Struct Template Reference

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >>

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >>:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1>
struct Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >>

Definition at line 436 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:22 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> Struct Template Reference

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >>

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >>:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2>
struct Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >>

Definition at line 445 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:23 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> Struct Template Reference

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >>

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >>:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3>
struct Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >>

Definition at line 455 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:24 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> Struct Template Reference

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >>

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >>:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4>
struct Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >>

Definition at line 466 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:24 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> Struct Template Reference

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >>

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >>:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5>
struct Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >>

Definition at line 479 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:25 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> Struct Template Reference

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >>

Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> Struct Template Reference

Inheritance diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >>:

[legend]
Collaboration diagram for Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
struct Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >>

Definition at line 494 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:26 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > > > > > > >> Struct Template Reference

Loki::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 > > > > > > >>

Loki::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 > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
struct Loki::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 > > > > > > >>

Definition at line 512 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:27 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > > > > > > > >> Struct Template Reference

Loki::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 > > > > > > > >>

Loki::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 > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
struct Loki::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 > > > > > > > >>

Definition at line 531 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:28 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > > > > > > > > >> Struct Template Reference

Loki::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 > > > > > > > > >>

Loki::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 > > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
struct Loki::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 > > > > > > > > >>

Definition at line 551 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:28 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > > > > > > > > > >> Struct Template Ref

Loki::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 > > > > > > > > > >>

Loki::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 > > > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
struct Loki::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 > > > > > > > > > >>

Definition at line 572 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:29 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > > > > > > > > > 

Loki::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 > > > > > > > > > > >>

Loki::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 > > > > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
struct Loki::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 > > > > > > > > > > >>

Definition at line 595 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:30 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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::NullT

Loki::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 > > > > > > > > > > > >>

Loki::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 > > > > > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
struct Loki::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 > > > > > > > > > > > >>

Definition at line 620 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:31 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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::Typel

Loki::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 > > > > > > > > > > > > >>

Loki::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 > > > > > > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
struct Loki::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 > > > > > > > > > > > > >>

Definition at line 646 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:31 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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::Typel

Loki::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 > > > > > > > > > > > > > >>

Loki::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 > > > > > > > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::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 > > > > > > > > > > > > > >>

Definition at line 673 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:32 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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::Typel

Loki::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 > > > > > > > > > > > > > > >>

Loki::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 > > > > > > > > > > > > > > >> Struct Template Reference

Inheritance diagram for Loki::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 > > > > > > > > > > > > > > >>:

[legend]
Collaboration diagram for Loki::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 > > > > > > > > > > > > > > >>:

[legend]
List of all members.

Public Types

typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14
typedef TypeTraits< P15
>::ParameterType 		Parm15

Public Member Functions

virtual ~FactoryImpl ()

Detailed Description

template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::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 > > > > > > > > > > > > > > >>

Definition at line 701 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:12:33 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FactoryImplBase Struct Reference

Loki::FactoryImplBase

Loki::FactoryImplBase Struct Reference

Inheritance diagram for Loki::FactoryImplBase:

[legend]
List of all members.

Public Types

typedef EmptyType | Parm1
typedef EmptyType | Parm2
typedef EmptyType | Parm3
typedef EmptyType | Parm4
typedef EmptyType | Parm5
typedef EmptyType | Parm6
typedef EmptyType | Parm7
typedef EmptyType | Parm8
typedef EmptyType | Parm9
typedef EmptyType | Parm10
typedef EmptyType | Parm11
typedef EmptyType | Parm12
typedef EmptyType | Parm13
typedef EmptyType | Parm14
typedef EmptyType | Parm15

Detailed Description

Definition at line 113 of file Factory.h.

The documentation for this struct was generated from the following file:
  • Factory.h
Generated on Sat Jul 7 15:11:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FieldHelper< H, i > Struct Template Reference

Loki::FieldHelper

Loki::FieldHelper< H, i > Struct Template Reference

List of all members.

Public Types

enum
typedef TL::TypeAt< typename
H::TList, i >::Result 		ElementType
typedef H::template Rebind<
ElementType >::Result 		UnitType
typedef const H::RightBase | ConstRightBase
typedef Select< isConst, ConstRightBase,
typename H::RightBase
>::Result 		RightBase
typedef Select< isTuple, ElementType,
UnitType >::Result 		UnqualifiedResultType
typedef Select< isConst, const
UnqualifiedResultType, UnqualifiedResultType
>::Result 		ResultType

Static Public Member Functions

static ResultType & | Do (H &obj)

Detailed Description

template<class H, unsigned int i>
struct Loki::FieldHelper< H, i >

Definition at line 184 of file HierarchyGenerators.h.

The documentation for this struct was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FieldHelper< H, 0 > Struct Template Reference

Loki::FieldHelper< H, 0 >

Loki::FieldHelper< H, 0 > Struct Template Reference

List of all members.

Public Types

enum
typedef H::TList::Head | ElementType
typedef H::template Rebind<
ElementType >::Result 		UnitType
typedef const H::LeftBase | ConstLeftBase
typedef Select< isConst, ConstLeftBase,
typename H::LeftBase >::Result 		LeftBase
typedef Select< isTuple, ElementType,
UnitType >::Result 		UnqualifiedResultType
typedef Select< isConst, const
UnqualifiedResultType, UnqualifiedResultType
>::Result 		ResultType

Static Public Member Functions

static ResultType & | Do (H &obj)

Detailed Description

template<class H>
struct Loki::FieldHelper< H, 0 >

Definition at line 154 of file HierarchyGenerators.h.

The documentation for this struct was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FixedAllocator Class Reference

Loki::FixedAllocator

Loki::FixedAllocator Class Reference
[Internals]

Collaboration diagram for Loki::FixedAllocator:

[legend]
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 Chunk * | HasBlock (void *p) const
Chunk * | HasBlock (void *p)

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.

Definition at line 168 of file SmallObj.cpp.

Member Function Documentation

void * Loki::FixedAllocator::Allocate ( void )

Returns pointer to allocated memory block of fixed size - or NULL if it failed to allocate.

Definition at line 829 of file SmallObj.cpp.

References Loki::Chunk::Allocate(), CountEmptyChunks(), Loki::Chunk::HasAvailable(), and Loki::Chunk::IsFilled().

Referenced by Loki::SmallObjAllocator::Allocate().

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.

Definition at line 879 of file SmallObj.cpp.

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:

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.

Definition at line 734 of file SmallObj.cpp.

References Loki::Chunk::blocksAvailable_, CountEmptyChunks(), Loki::Chunk::HasAvailable(), and Loki::Chunk::Release().

Referenced by ~FixedAllocator().

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.

Definition at line 779 of file SmallObj.cpp.

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.

Definition at line 584 of file SmallObj.cpp.

Referenced by Allocate(), Deallocate(), IsCorrupt(), and TrimEmptyChunk().

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.

Definition at line 605 of file SmallObj.cpp.

References CountEmptyChunks(), and Loki::Chunk::HasAvailable().

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.

Definition at line 720 of file SmallObj.cpp.

Referenced by HasBlock().

The documentation for this class was generated from the following file:
  • SmallObj.cpp
Generated on Sat Jul 7 15:12:21 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > Class Template Reference

Loki::FnDispatcher

Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > Class Template Reference

List of all members.

Public Member Functions

template<class SomeLhs, class SomeRhs>
void | Add (ResultType(*pFun)(BaseLhs &, BaseRhs &))
template<class SomeLhs, class SomeRhs, ResultType(*)(SomeLhs &, SomeRhs &) callback>
void | Add ()
template<class SomeLhs, class SomeRhs, ResultType(*)(SomeLhs &, SomeRhs &) callback, bool symmetric>
void | Add (bool=true)
template<class SomeLhs, class SomeRhs>
void | Remove ()
ResultType | Go (BaseLhs &lhs, BaseRhs &rhs)

Detailed Description

template<class BaseLhs, class BaseRhs = BaseLhs, typename ResultType = void, template< class, class > class CastingPolicy = DynamicCaster, template< class, class, class, class > class DispatcherBackend = BasicDispatcher>
class Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >

Definition at line 255 of file MultiMethods.h.

The documentation for this class was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback > Struct Template Reference

Loki::Private::FnDispatcherHelper

Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback > Struct Template Reference

List of all members.

Static Public Member Functions

static ResultType | Trampoline (BaseLhs &lhs, BaseRhs &rhs)
static ResultType | TrampolineR (BaseRhs &rhs, BaseLhs &lhs)

Detailed Description

template<class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs, typename ResultType, class CastLhs, class CastRhs, ResultType(*)(SomeLhs &, SomeRhs &) Callback>
struct Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback >

Definition at line 231 of file MultiMethods.h.

The documentation for this struct was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FollowIntoDeath Class Reference

Loki::FollowIntoDeath

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
  • master never dies (NoDestroy policy)
  • master never created
  • master dies not in the function registered with atexit
  • master dies not by a call of a the atexit registerd function (DeletableSingleton::GracefulDelete)

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

Definition at line 606 of file Singleton.h.

The documentation for this class was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FollowIntoDeath::AfterMaster< Master > Struct Template Reference

Loki::FollowIntoDeath::AfterMaster

Loki::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

Definition at line 677 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F > Struct Template Reference

Loki::FollowIntoDeath::AfterMaster::IsDestroyed

Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F > Struct Template Reference

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void | ScheduleDestruction (F *, atexit_pfn_t pFun)
static void | OnDeadReference ()

Detailed Description

template<class Master>
template<class F>
struct Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F >

Policy for followers

Definition at line 682 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FollowIntoDeath::With< Lifetime > Struct Template Reference

Loki::FollowIntoDeath::With

Loki::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

Definition at line 647 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master > Struct Template Reference

Loki::FollowIntoDeath::With::AsMasterLifetime

Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master > Struct Template Reference

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void | ScheduleDestruction (Master *pObj, atexit_pfn_t pFun)
static void | OnDeadReference ()

Detailed Description

template<template< class > class Lifetime>
template<class Master>
struct Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master >

Policy for master

Definition at line 652 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Function Struct Reference

Function Struct Reference
[Function objects]

#include <Function.h>

Detailed Description

Allows a boost/TR1 like usage of Functor.

Usage
  • free functions: e.g.
     Function<int(int,int)> f(&freeFunction);
  • member functions: e.g
     Function<int()> f(&object,&ObjectType::memberFunction);

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 Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R()> Struct Template Reference

Loki::Function< R()>

Loki::Function< R()> Struct Template Reference

Inheritance diagram for Loki::Function< R()>:

[legend]
Collaboration diagram for Loki::Function< R()>:

[legend]
List of all members.

Public Types

typedef Functor< R > FBase

Public Member Functions

Function ()
Function (const Function &func)
template<class R2>
Function (Function< R2()> func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R>
struct Loki::Function< R()>

Definition at line 47 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01)> Struct Template Reference

Loki::Function< R(P01)>

Loki::Function< R(P01)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01)>:

[legend]
Collaboration diagram for Loki::Function< R(P01)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01 > > FBase

Public Member Functions

template<class R2, class Q01>
Function (Function< R2(Q01)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01>
struct Loki::Function< R(P01)>

Definition at line 145 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02)> Struct Template Reference

Loki::Function< R(P01, P02)>

Loki::Function< R(P01, P02)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02>
Function (Function< R2(Q01, Q02)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02>
struct Loki::Function< R(P01, P02)>

Definition at line 158 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03)> Struct Template Reference

Loki::Function< R(P01, P02, P03)>

Loki::Function< R(P01, P02, P03)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03>
Function (Function< R2(Q01, Q02, Q03)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03>
struct Loki::Function< R(P01, P02, P03)>

Definition at line 171 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04)>

Loki::Function< R(P01, P02, P03, P04)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04>
Function (Function< R2(Q01, Q02, Q03, Q04)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04>
struct Loki::Function< R(P01, P02, P03, P04)>

Definition at line 184 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05)>

Loki::Function< R(P01, P02, P03, P04, P05)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05>
struct Loki::Function< R(P01, P02, P03, P04, P05)>

Definition at line 197 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06)>

Loki::Function< R(P01, P02, P03, P04, P05, P06)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06)>

Definition at line 211 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:51 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)>

Definition at line 226 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)>

Definition at line 241 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08, P09 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08, class Q09>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08, class P09>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>

Definition at line 256 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08, P09, P10 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08, class Q09, class Q10>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08, class P09, class P10>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>

Definition at line 271 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:52 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08, P09, P10, P11 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08, class Q09, class Q10, class Q11>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08, class P09, class P10, class P11>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>

Definition at line 287 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:53 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08, P09, P10, P11,
P12 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08, class Q09, class Q10, class Q11, class Q12>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08, class P09, class P10, class P11, class P12>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>

Definition at line 304 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:53 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08, P09, P10, P11,
P12, P13 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08, class Q09, class Q10, class Q11, class Q12, class Q13>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08, class P09, class P10, class P11, class P12, class P13>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>

Definition at line 321 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:53 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08, P09, P10, P11,
P12, P13, P14 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08, class Q09, class Q10, class Q11, class Q12, class Q13, class Q14>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13, Q14)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08, class P09, class P10, class P11, class P12, class P13, class P14>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>

Definition at line 338 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:54 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Struct Template Reference

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>

Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Struct Template Reference

Inheritance diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>:

[legend]
Collaboration diagram for Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>:

[legend]
List of all members.

Public Types

typedef Functor< R, Seq< P01,
P02, P03, P04, P05, P06,
P07, P08, P09, P10, P11,
P12, P13, P14, P15 > > 		FBase

Public Member Functions

template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05, class Q06, class Q07, class Q08, class Q09, class Q10, class Q11, class Q12, class Q13, class Q14, class Q15>
Function (Function< R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13, Q14, Q15)> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<class R, class P01, class P02, class P03, class P04, class P05, class P06, class P07, class P08, class P09, class P10, class P11, class P12, class P13, class P14, class P15>
struct Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>

Definition at line 354 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:54 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Function<> Struct Template Reference

Loki::Function<>

Loki::Function<> Struct Template Reference

Inheritance diagram for Loki::Function<>:

[legend]
Collaboration diagram for Loki::Function<>:

[legend]
List of all members.

Public Types

typedef Functor FBase

Public Member Functions

template<class R2>
Function (Function< R2()> func)
Function ()
Function (const Function &func)
Function (const int i)
template<class Func>
Function (Func func)
template<class Host, class Func>
Function (const Host &host, const Func &func)

Detailed Description

template<>
struct Loki::Function<>

Definition at line 129 of file Function.h.

The documentation for this struct was generated from the following file:
  • Function.h
Generated on Sat Jul 7 15:11:50 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctionStorage< T > Class Template Reference

Loki::FunctionStorage

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

FunctionStorage ()
FunctionStorage (const FunctionStorage &rsh)
template<class U>
FunctionStorage (const FunctionStorage< U > &rsh)
FunctionStorage (const StoredType &p)
PointerType | operator-> () const
ReferenceType | operator * () const
void | Swap (FunctionStorage &rhs)
void | SetCallBackFunction (const FunctorType &functor)

Protected Member Functions

void | Destroy ()

Static Protected Member Functions

static StoredType | Default ()

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.

Definition at line 62 of file SPCachedFactory.h.

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.

Definition at line 102 of file SPCachedFactory.h.

The documentation for this class was generated from the following file:
  • SPCachedFactory.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Functor< R, TList, ThreadingModel > Class Template Reference

Loki::Functor

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.

Public Types

typedef FunctorImpl< R, TList,
ThreadingModel > 		Impl
typedef R | ResultType
typedef TList | ParmList
typedef Impl::Parm1 | Parm1
typedef Impl::Parm2 | Parm2
typedef Impl::Parm3 | Parm3
typedef Impl::Parm4 | Parm4
typedef Impl::Parm5 | Parm5
typedef Impl::Parm6 | Parm6
typedef Impl::Parm7 | Parm7
typedef Impl::Parm8 | Parm8
typedef Impl::Parm9 | Parm9
typedef Impl::Parm10 | Parm10
typedef Impl::Parm11 | Parm11
typedef Impl::Parm12 | Parm12
typedef Impl::Parm13 | Parm13
typedef Impl::Parm14 | Parm14
typedef Impl::Parm15 | Parm15
typedef Impl *(std::auto_ptr<
Impl >::*) 		unspecified_bool_type () const

Public Member Functions

Functor ()
Functor (const Functor &rhs)
Functor (std::auto_ptr< Impl > spImpl)
template<typename Fun>
Functor (Fun fun)
template<class PtrObj, typename MemFn>
Functor (const PtrObj &p, MemFn memFn)
operator unspecified_bool_type () const
Functor & | operator= (const Functor &rhs)
ResultType | operator() () const
ResultType | operator() (Parm1 p1) const
ResultType | operator() (Parm1 p1, Parm2 p2) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) const
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const

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

Definition at line 1219 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > Class Template Reference

Loki::FunctorDispatcher

Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > Class Template Reference

List of all members.

Public Member Functions

template<class SomeLhs, class SomeRhs, class Fun>
void | Add (const Fun &fun)
template<class SomeLhs, class SomeRhs, bool symmetric, class Fun>
void | Add (const Fun &fun)
template<class SomeLhs, class SomeRhs>
void | Remove ()
ResultType | Go (BaseLhs &lhs, BaseRhs &rhs)

Detailed Description

template<class BaseLhs, class BaseRhs = BaseLhs, typename ResultType = void, template< class, class > class CastingPolicy = DynamicCaster, template< class, class, class, class > class DispatcherBackend = BasicDispatcher>
class Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >

Definition at line 358 of file MultiMethods.h.

The documentation for this class was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs > Class Template Reference

Loki::Private::FunctorDispatcherHelper

Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs > Class Template Reference

List of all members.

Public Member Functions

FunctorDispatcherHelper (const Fun &fun)
ResultType operator() (BaseLhs &lhs, BaseRhs &rhs)

Detailed Description

template<class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs, typename ResultType, class CastLhs, class CastRhs, class Fun, bool SwapArgs>
class Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs >

Definition at line 326 of file MultiMethods.h.

The documentation for this class was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorHandler< ParentFunctor, Fun > Class Template Reference

Loki::FunctorHandler

Loki::FunctorHandler< ParentFunctor, Fun > Class Template Reference

List of all members.

Public Types

typedef Base::ResultType | ResultType
typedef Base::Parm1 | Parm1
typedef Base::Parm2 | Parm2
typedef Base::Parm3 | Parm3
typedef Base::Parm4 | Parm4
typedef Base::Parm5 | Parm5
typedef Base::Parm6 | Parm6
typedef Base::Parm7 | Parm7
typedef Base::Parm8 | Parm8
typedef Base::Parm9 | Parm9
typedef Base::Parm10 | Parm10
typedef Base::Parm11 | Parm11
typedef Base::Parm12 | Parm12
typedef Base::Parm13 | Parm13
typedef Base::Parm14 | Parm14
typedef Base::Parm15 | Parm15

Public Member Functions

FunctorHandler (const Fun &fun)
virtual FunctorHandler * | DoClone () const
ResultType operator() ()
ResultType | operator() (Parm1 p1)
ResultType | operator() (Parm1 p1, Parm2 p2)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)

Detailed Description

template<class ParentFunctor, typename Fun>
class Loki::FunctorHandler< ParentFunctor, Fun >

Definition at line 924 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, NullType, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, NullType, ThreadingModel >

Loki::FunctorImpl< R, NullType, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, NullType, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, NullType, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType

Detailed Description

template<typename R, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, NullType, ThreadingModel >

Definition at line 134 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:54 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1

Detailed Description

template<typename R, typename P1, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel >

Definition at line 148 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:55 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2

Detailed Description

template<typename R, typename P1, typename P2, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel >

Definition at line 164 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:55 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3

Detailed Description

template<typename R, typename P1, typename P2, typename P3, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel >

Definition at line 181 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:55 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel >

Definition at line 199 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:56 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel >

Definition at line 219 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:56 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel >

Definition at line 240 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:57 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel >

Definition at line 262 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:57 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel >

Definition at line 286 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:57 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel >

Definition at line 312 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:58 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel >

Definition at line 340 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:58 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel >

Definition at line 369 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:59 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >

Definition at line 400 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:59 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel >

Definition at line 432 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:11:59 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel >

Definition at line 465 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >

Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14
typedef TypeTraits< P15
>::ParameterType 		Parm15

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >

Definition at line 500 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel >

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1

Detailed Description

template<typename R, typename P1, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel >

Definition at line 536 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:23 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel >

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2

Detailed Description

template<typename R, typename P1, typename P2, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel >

Definition at line 552 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:23 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel >

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3

Detailed Description

template<typename R, typename P1, typename P2, typename P3, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel >

Definition at line 569 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:24 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel >

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel >

Definition at line 587 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:25 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel >

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel >

Definition at line 607 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:26 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > Class Template Reference

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel >

Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > Class Template Reference

Inheritance diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel >:

[legend]
Collaboration diagram for Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, template< class, class > class ThreadingModel>
class Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel >

Definition at line 628 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:26 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > Class Template Reference

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 650 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:27 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > Class Template Reference

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 674 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:28 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > Class Template Reference

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 700 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:29 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > Class T

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 728 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:29 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 > > > > > > > > > > >, 

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 757 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:30 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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 >

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 788 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:31 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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< 

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 820 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:32 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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< 

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 853 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:33 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::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< 

Loki::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 >

Loki::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 > Class Template Reference

Inheritance diagram for Loki::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 >:

[legend]
Collaboration diagram for Loki::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 >:

[legend]
List of all members.

Public Types

typedef R ResultType
typedef TypeTraits< P1
>::ParameterType 		Parm1
typedef TypeTraits< P2
>::ParameterType 		Parm2
typedef TypeTraits< P3
>::ParameterType 		Parm3
typedef TypeTraits< P4
>::ParameterType 		Parm4
typedef TypeTraits< P5
>::ParameterType 		Parm5
typedef TypeTraits< P6
>::ParameterType 		Parm6
typedef TypeTraits< P7
>::ParameterType 		Parm7
typedef TypeTraits< P8
>::ParameterType 		Parm8
typedef TypeTraits< P9
>::ParameterType 		Parm9
typedef TypeTraits< P10
>::ParameterType 		Parm10
typedef TypeTraits< P11
>::ParameterType 		Parm11
typedef TypeTraits< P12
>::ParameterType 		Parm12
typedef TypeTraits< P13
>::ParameterType 		Parm13
typedef TypeTraits< P14
>::ParameterType 		Parm14
typedef TypeTraits< P15
>::ParameterType 		Parm15

Detailed Description

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, template< class, class > class ThreadingModel>
class Loki::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 >

Definition at line 888 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:34 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::FunctorImplBase< R, ThreadingModel > Struct Template Reference

Loki::Private::FunctorImplBase

Loki::Private::FunctorImplBase< R, ThreadingModel > Struct Template Reference

Inheritance diagram for Loki::Private::FunctorImplBase< R, ThreadingModel >:

[legend]
Collaboration diagram for Loki::Private::FunctorImplBase< R, ThreadingModel >:

[legend]
List of all members.

Public Types

typedef R | ResultType
typedef FunctorImplBase< R,
ThreadingModel > 		FunctorImplBaseType
typedef EmptyType | Parm1
typedef EmptyType | Parm2
typedef EmptyType | Parm3
typedef EmptyType | Parm4
typedef EmptyType | Parm5
typedef EmptyType | Parm6
typedef EmptyType | Parm7
typedef EmptyType | Parm8
typedef EmptyType | Parm9
typedef EmptyType | Parm10
typedef EmptyType | Parm11
typedef EmptyType | Parm12
typedef EmptyType | Parm13
typedef EmptyType | Parm14
typedef EmptyType | Parm15

Public Member Functions

FunctorImplBase ()
FunctorImplBase (const FunctorImplBase &)
virtual | ~FunctorImplBase ()

Static Public Member Functions

template<class U>
static U * | Clone (U *pObj)

Detailed Description

template<typename R, template< class, class > class ThreadingModel>
struct Loki::Private::FunctorImplBase< R, ThreadingModel >

Definition at line 51 of file Functor.h.

The documentation for this struct was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:37 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenLinearHierarchy< NullType, Unit, Root > Class Template Reference

Loki::GenLinearHierarchy< NullType, Unit, Root >

Loki::GenLinearHierarchy< NullType, Unit, Root > Class Template Reference

Detailed Description

template<template< class, class > class Unit, class Root>
class Loki::GenLinearHierarchy< NullType, Unit, Root >

Definition at line 280 of file HierarchyGenerators.h.

The documentation for this class was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenLinearHierarchy< Typelist< T, NullType >, Unit, Root > Class Template Reference

Loki::GenLinearHierarchy< Typelist< T, NullType >, Unit, Root >

Loki::GenLinearHierarchy< Typelist< T, NullType >, Unit, Root > Class Template Reference

Detailed Description

template<class T, template< class, class > class Unit, class Root>
class Loki::GenLinearHierarchy< Typelist< T, NullType >, Unit, Root >

Definition at line 270 of file HierarchyGenerators.h.

The documentation for this class was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root > Class Template Reference

Loki::GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root >

Loki::GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root > Class Template Reference

Detailed Description

template<class T1, class T2, template< class, class > class Unit, class Root>
class Loki::GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root >

Definition at line 259 of file HierarchyGenerators.h.

The documentation for this class was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenScatterHierarchy< AtomicType, Unit > Class Template Reference

Loki::GenScatterHierarchy

Loki::GenScatterHierarchy< AtomicType, Unit > Class Template Reference

Inheritance diagram for Loki::GenScatterHierarchy< AtomicType, Unit >:

[legend]
List of all members.

Detailed Description

template<class AtomicType, template< class > class Unit>
class Loki::GenScatterHierarchy< AtomicType, Unit >

Definition at line 83 of file HierarchyGenerators.h.

The documentation for this class was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenScatterHierarchy< NullType, Unit > Class Template Reference

Loki::GenScatterHierarchy< NullType, Unit >

Loki::GenScatterHierarchy< NullType, Unit > Class Template Reference

Detailed Description

template<template< class > class Unit>
class Loki::GenScatterHierarchy< NullType, Unit >

Definition at line 93 of file HierarchyGenerators.h.

The documentation for this class was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit > Class Template Reference

Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit >

Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit > Class Template Reference

Inheritance diagram for Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit >:

[legend]
Collaboration diagram for Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit >:

[legend]

Detailed Description

template<class T1, class T2, template< class > class Unit>
class Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit >

Definition at line 77 of file HierarchyGenerators.h.

The documentation for this class was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:21 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > Class Template Reference

Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >

Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > Class Template Reference

Inheritance diagram for Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >:

[legend]
Collaboration diagram for Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >:

[legend]
List of all members.

Public Types

typedef Typelist< T1, T2 > | TList
typedef GenScatterHierarchy<
Private::ScatterHierarchyTag<
T1, T2 >, Unit > 		LeftBase
typedef GenScatterHierarchy<
T2, Unit > 		RightBase

Classes

struct | Rebind

Detailed Description

template<class T1, class T2, template< class > class Unit>
class Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >

Definition at line 60 of file HierarchyGenerators.h.

The documentation for this class was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T > Struct Template Reference

Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind

Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T > Struct Template Reference

List of all members.

Public Types

typedef Unit< T > Result

Detailed Description

template<class T1, class T2, template< class > class Unit>
template<typename T>
struct Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T >

Definition at line 69 of file HierarchyGenerators.h.

The documentation for this struct was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:02 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::HeapStorage< T > Class Template Reference

Loki::HeapStorage

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

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * | StoredType
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*
HeapStorage (const HeapStorage &)
template<class U>
HeapStorage (const HeapStorage< U > &)
HeapStorage (const StoredType &p)
PointerType | operator-> () const
ReferenceType | operator * () const
void | Swap (HeapStorage &rhs)

Protected Member Functions

void | Destroy ()

Static Protected Member Functions

static StoredType | Default ()

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.

Definition at line 67 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


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:
  • Pimpl.h
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::IndexOf< NullType, T > Struct Template Reference

Loki::TL::IndexOf< NullType, T >

Loki::TL::IndexOf< NullType, T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<class T>
struct Loki::TL::IndexOf< NullType, T >

Definition at line 178 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::IndexOf< Typelist< Head, Tail >, T > Struct Template Reference

Loki::TL::IndexOf< Typelist< Head, Tail >, T >

Loki::TL::IndexOf< Typelist< Head, Tail >, T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<class Head, class Tail, class T>
struct Loki::TL::IndexOf< Typelist< Head, Tail >, T >

Definition at line 190 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::IndexOf< Typelist< T, Tail >, T > Struct Template Reference

Loki::TL::IndexOf< Typelist< T, Tail >, T >

Loki::TL::IndexOf< Typelist< T, Tail >, T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<class T, class Tail>
struct Loki::TL::IndexOf< Typelist< T, Tail >, T >

Definition at line 184 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Int2Type< v > Struct Template Reference

Loki::Int2Type

Loki::Int2Type< v > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<int v>
struct Loki::Int2Type< v >

Definition at line 31 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType > Struct Template Reference

Loki::Private::InvocationTraits

Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType > Struct Template Reference

List of all members.

Static Public Member Functions

static ResultType | DoDispatch (SomeLhs &lhs, SomeRhs &rhs, Executor &exec, Int2Type< false >)
static ResultType | DoDispatch (SomeLhs &lhs, SomeRhs &rhs, Executor &exec, Int2Type< true >)

Detailed Description

template<class SomeLhs, class SomeRhs, class Executor, typename ResultType>
struct Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType >

Definition at line 43 of file MultiMethods.h.

The documentation for this struct was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::IsCustomFloat< T > Struct Template Reference

Loki::IsCustomFloat

Loki::IsCustomFloat< T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::IsCustomFloat< T >

Definition at line 84 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::IsCustomSignedInt< T > Struct Template Reference

Loki::IsCustomSignedInt

Loki::IsCustomSignedInt< T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::IsCustomSignedInt< T >

Definition at line 67 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::IsCustomUnsignedInt< T > Struct Template Reference

Loki::IsCustomUnsignedInt

Loki::IsCustomUnsignedInt< T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::IsCustomUnsignedInt< T >

Definition at line 49 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T > Struct Template Reference

Loki::Private::IsFunctionPointerRaw

Loki::Private::IsFunctionPointerRaw< T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::Private::IsFunctionPointerRaw< T >

Definition at line 156 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)()> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)()>

Loki::Private::IsFunctionPointerRaw< T(*)()> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::Private::IsFunctionPointerRaw< T(*)()>

Definition at line 160 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(...)>

Loki::Private::IsFunctionPointerRaw< T(*)(...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::Private::IsFunctionPointerRaw< T(*)(...)>

Definition at line 343 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01)>

Definition at line 165 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)>

Definition at line 170 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)>

Definition at line 176 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)>

Definition at line 182 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)>

Definition at line 188 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)>

Definition at line 195 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)>

Definition at line 203 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)>

Definition at line 211 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>

Definition at line 219 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>

Definition at line 227 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>

Definition at line 236 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>

Definition at line 246 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>

Definition at line 256 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>

Definition at line 266 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>

Definition at line 276 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>

Definition at line 287 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>

Definition at line 299 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>

Definition at line 311 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>

Definition at line 323 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>

Definition at line 335 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>

Definition at line 523 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>

Definition at line 511 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>

Definition at line 499 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>

Definition at line 487 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>

Definition at line 475 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>

Definition at line 463 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>

Definition at line 453 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>

Definition at line 443 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>

Definition at line 433 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>

Definition at line 423 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>

Definition at line 413 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>

Definition at line 405 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>

Definition at line 397 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)>

Definition at line 389 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)>

Definition at line 381 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)>

Definition at line 373 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)>

Definition at line 367 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02, typename P03>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)>

Definition at line 361 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01, typename P02>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)>

Definition at line 355 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)> Struct Template Reference

Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)>

Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename P01>
struct Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)>

Definition at line 349 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:40 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw

Loki::Private::IsMemberFunctionPointerRaw< T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::Private::IsMemberFunctionPointerRaw< T >

Definition at line 533 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const >

Definition at line 911 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile >

Definition at line 1659 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile >

Definition at line 1285 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()>

Definition at line 537 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const >

Definition at line 1094 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile >

Definition at line 1842 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile >

Definition at line 1468 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)>

Definition at line 720 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const >

Definition at line 916 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile >

Definition at line 1664 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile >

Definition at line 1290 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)>

Definition at line 542 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const >

Definition at line 921 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile >

Definition at line 1669 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile >

Definition at line 1295 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)>

Definition at line 547 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const >

Definition at line 927 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile >

Definition at line 1675 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile >

Definition at line 1301 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)>

Definition at line 553 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const >

Definition at line 933 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile >

Definition at line 1681 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile >

Definition at line 1307 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)>

Definition at line 559 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const >

Definition at line 939 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile >

Definition at line 1687 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile >

Definition at line 1313 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)>

Definition at line 565 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const >

Definition at line 946 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile >

Definition at line 1694 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile >

Definition at line 1320 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)>

Definition at line 572 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const >

Definition at line 954 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile >

Definition at line 1702 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile >

Definition at line 1328 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)>

Definition at line 580 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const >

Definition at line 962 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile >

Definition at line 1710 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile >

Definition at line 1336 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)>

Definition at line 588 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const >

Definition at line 970 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile >

Definition at line 1718 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile >

Definition at line 1344 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>

Definition at line 596 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const >

Definition at line 978 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile >

Definition at line 1726 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile >

Definition at line 1352 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>

Definition at line 604 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const >

Definition at line 987 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile >

Definition at line 1735 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile >

Definition at line 1361 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>

Definition at line 613 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const >

Definition at line 997 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile >

Definition at line 1745 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile >

Definition at line 1371 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>

Definition at line 623 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const >

Definition at line 1007 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile >

Definition at line 1755 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile >

Definition at line 1381 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>

Definition at line 633 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const >

Definition at line 1017 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile >

Definition at line 1765 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile >

Definition at line 1391 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>

Definition at line 643 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const >

Definition at line 1027 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile >

Definition at line 1775 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile >

Definition at line 1401 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>

Definition at line 653 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const >

Definition at line 1038 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile >

Definition at line 1786 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile >

Definition at line 1412 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>

Definition at line 664 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const >

Definition at line 1050 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile >

Definition at line 1798 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile >

Definition at line 1424 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>

Definition at line 676 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const >

Definition at line 1062 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile >

Definition at line 1810 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile >

Definition at line 1436 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>

Definition at line 688 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const >

Definition at line 1074 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile >

Definition at line 1822 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile >

Definition at line 1448 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>

Definition at line 700 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const >

Definition at line 1086 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile >

Definition at line 1834 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile >

Definition at line 1460 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>

Definition at line 712 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const >

Definition at line 1274 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile >

Definition at line 2022 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile >

Definition at line 1648 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19, typename P20>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>

Definition at line 900 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const >

Definition at line 1262 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile >

Definition at line 2010 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile >

Definition at line 1636 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18, typename P19>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>

Definition at line 888 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const >

Definition at line 1250 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile >

Definition at line 1998 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile >

Definition at line 1624 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17, typename P18>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>

Definition at line 876 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const >

Definition at line 1238 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile >

Definition at line 1986 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile >

Definition at line 1612 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename P17>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>

Definition at line 864 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const >

Definition at line 1226 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile >

Definition at line 1974 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile >

Definition at line 1600 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>

Definition at line 852 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const >

Definition at line 1214 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile >

Definition at line 1962 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile >

Definition at line 1588 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>

Definition at line 840 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const >

Definition at line 1204 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile >

Definition at line 1952 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile >

Definition at line 1578 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13, typename P14>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>

Definition at line 830 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const >

Definition at line 1194 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile >

Definition at line 1942 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile >

Definition at line 1568 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12, typename P13>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>

Definition at line 820 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const >

Definition at line 1184 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile >

Definition at line 1932 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile >

Definition at line 1558 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11, typename P12>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>

Definition at line 810 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const >

Definition at line 1174 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile >

Definition at line 1922 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile >

Definition at line 1548 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10, typename P11>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>

Definition at line 800 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const >

Definition at line 1164 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile >

Definition at line 1912 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile >

Definition at line 1538 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09, typename P10>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>

Definition at line 790 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const >

Definition at line 1156 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile >

Definition at line 1904 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile >

Definition at line 1530 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08, typename P09>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>

Definition at line 782 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const >

Definition at line 1148 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile >

Definition at line 1896 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile >

Definition at line 1522 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07, typename P08>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>

Definition at line 774 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const >

Definition at line 1140 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile >

Definition at line 1888 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile >

Definition at line 1514 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06, typename P07>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)>

Definition at line 766 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const >

Definition at line 1132 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile >

Definition at line 1880 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile >

Definition at line 1506 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05, typename P06>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)>

Definition at line 758 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const >

Definition at line 1124 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile >

Definition at line 1872 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile >

Definition at line 1498 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04, typename P05>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)>

Definition at line 750 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const >

Definition at line 1118 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile >

Definition at line 1866 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile >

Definition at line 1492 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03, typename P04>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)>

Definition at line 744 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const >

Definition at line 1112 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile >

Definition at line 1860 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile >

Definition at line 1486 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02, typename P03>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)>

Definition at line 738 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const >

Definition at line 1106 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile >

Definition at line 1854 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile >

Definition at line 1480 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01, typename P02>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)>

Definition at line 732 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const >

Definition at line 1100 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile >

Definition at line 1848 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile > Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile >

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile >

Definition at line 1474 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)> Struct Template Reference

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)>

Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)> Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename S, typename P01>
struct Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)>

Definition at line 726 of file TypeTraits.h.

The documentation for this struct was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:41 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::IsSameType< T, U > Struct Template Reference

Loki::IsSameType

Loki::IsSameType< T, U > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T, typename U>
struct Loki::IsSameType< T, U >

Definition at line 80 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::IsSameType< T, T > Struct Template Reference

Loki::IsSameType< T, T >

Loki::IsSameType< T, T > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<typename T>
struct Loki::IsSameType< T, T >

Definition at line 86 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::IterateTypes< AtomicType, GenFunc > Struct Template Reference

Loki::TL::IterateTypes

Loki::TL::IterateTypes< AtomicType, GenFunc > Struct Template Reference

List of all members.

Public Member Functions

template<class II>
void operator() (II ii)

Detailed Description

template<class AtomicType, template< class > class GenFunc>
struct Loki::TL::IterateTypes< AtomicType, GenFunc >

Definition at line 84 of file DataGenerators.h.

The documentation for this struct was generated from the following file:
  • DataGenerators.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::IterateTypes< NullType, GenFunc > Struct Template Reference

Loki::TL::IterateTypes< NullType, GenFunc >

Loki::TL::IterateTypes< NullType, GenFunc > Struct Template Reference

List of all members.

Public Member Functions

template<class II>
void operator() (II ii)

Detailed Description

template<template< class > class GenFunc>
struct Loki::TL::IterateTypes< NullType, GenFunc >

Definition at line 96 of file DataGenerators.h.

The documentation for this struct was generated from the following file:
  • DataGenerators.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > Struct Template Reference

Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >

Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc > Struct Template Reference

Collaboration diagram for Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >:

[legend]
List of all members.

Public Types

typedef IterateTypes< T1,
GenFunc > 		head_t
typedef IterateTypes< T2,
GenFunc > 		tail_t

Public Member Functions

template<class II>
void operator() (II ii)

Public Attributes

head_t head
tail_t tail

Detailed Description

template<class T1, class T2, template< class > class GenFunc>
struct Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >

Definition at line 69 of file DataGenerators.h.

The documentation for this struct was generated from the following file:
  • DataGenerators.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


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

Loki::Key

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

#include <Key.h>

List of all members.

Public Member Functions

Key ()
Key (const IdentifierType &id)
Key (const IdentifierType &id, Parm1 &p1)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12, Parm13 &p13)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14)
Key (const IdentifierType &id, Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14, Parm15 &p15)

Public Attributes

int | count
IdentifierType | id
Parm1 | p1
Parm2 | p2
Parm3 | p3
Parm4 | p4
Parm5 | p5
Parm6 | p6
Parm7 | p7
Parm8 | p8
Parm9 | p9
Parm10 | p10
Parm11 | p11
Parm12 | p12
Parm13 | p13
Parm14 | p14
Parm15 | p15

Detailed Description

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

A Key class

Definition at line 51 of file Key.h.

The documentation for this class was generated from the following file:
  • Key.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Length< NullType > Struct Template Reference

Loki::TL::Length< NullType >

Loki::TL::Length< NullType > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<>
struct Loki::TL::Length< NullType >

Definition at line 100 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Length< Typelist< T, U > > Struct Template Reference

Loki::TL::Length< Typelist< T, U > >

Loki::TL::Length< Typelist< T, U > > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<class T, class U>
struct Loki::TL::Length< Typelist< T, U > >

Definition at line 106 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > > Struct Template Reference

std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > >

std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > > Struct Template Reference

List of all members.

Public Member Functions

bool operator() (const Loki::SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, const Loki::SmartPtr< T, OP, CP, KP, SP, CNP > &rhs) const

Detailed Description

template<typename T, template< class > class OP, class CP, template< class > class KP, template< class > class SP, template< class > class CNP>
struct std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > >

Definition at line 1752 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


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

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

#include <StrongPtr.h>

List of all members.

Public Member Functions

bool operator() (const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &lhs, const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs) const

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

Definition at line 1663 of file StrongPtr.h.

The documentation for this struct was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::LifetimeTracker Class Reference

Loki::Private::LifetimeTracker

Loki::Private::LifetimeTracker Class Reference

Inheritance diagram for Loki::Private::LifetimeTracker:

[legend]
List of all members.

Public Member Functions

LifetimeTracker (unsigned int x)
virtual | ~LifetimeTracker ()=0

Static Public Member Functions

static bool | Compare (const LifetimeTracker *lhs, const LifetimeTracker *rhs)

Detailed Description

Definition at line 87 of file Singleton.h.

The documentation for this class was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


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:
  • StrongPtr.h
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


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:
  • StrongPtr.h
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::LockedStorage< T > Class Template Reference

Loki::LockedStorage

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

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * | StoredType
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*
~LockedStorage (void)
LockedStorage (const LockedStorage &)
LockedStorage (const StoredType &p)
PointerType operator-> ()
void | Swap (LockedStorage &rhs)

Protected Member Functions

void | Destroy ()

Static Protected Member Functions

static StoredType | Default ()

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.

Definition at line 274 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Locker< T > Class Template Reference

Loki::Locker

Loki::Locker< T > Class Template Reference

List of all members.

Public Member Functions

Locker (const T *p)
~Locker (void)
operator T * ()
T * operator-> ()

Detailed Description

template<class T>
class Loki::Locker< T >

Definition at line 242 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


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

Loki::LockingPtr

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

#include <LockingPtr.h>

List of all members.

Public Types

typedef ConstPolicy< SharedObject
>::Type 		ConstOrNotType
typedef std::pair< volatile
ConstOrNotType *, LockingPolicy * > 		Pair

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.

Definition at line 32 of file LockingPtr.h.

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.

Definition at line 42 of file LockingPtr.h.

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

Definition at line 54 of file LockingPtr.h.

The documentation for this class was generated from the following file:
  • LockingPtr.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 > Struct Template Reference

Loki::TL::MakeTypelist

Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 > Struct Template Reference

List of all members.

Public Types

typedef Typelist< T1, TailResult > Result

Detailed Description

template<typename T1 = NullType, typename T2 = NullType, typename T3 = NullType, typename T4 = NullType, typename T5 = NullType, typename T6 = NullType, typename T7 = NullType, typename T8 = NullType, typename T9 = NullType, typename T10 = NullType, typename T11 = NullType, typename T12 = NullType, typename T13 = NullType, typename T14 = NullType, typename T15 = NullType, typename T16 = NullType, typename T17 = NullType, typename T18 = NullType>
struct Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >

Definition at line 66 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::MakeTypelist<> Struct Template Reference

Loki::TL::MakeTypelist<>

Loki::TL::MakeTypelist<> Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<>
struct Loki::TL::MakeTypelist<>

Definition at line 85 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > Class Template Reference

Loki::MemFunHandler

Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > Class Template Reference

List of all members.

Public Types

typedef Base::ResultType | ResultType
typedef Base::Parm1 | Parm1
typedef Base::Parm2 | Parm2
typedef Base::Parm3 | Parm3
typedef Base::Parm4 | Parm4
typedef Base::Parm5 | Parm5
typedef Base::Parm6 | Parm6
typedef Base::Parm7 | Parm7
typedef Base::Parm8 | Parm8
typedef Base::Parm9 | Parm9
typedef Base::Parm10 | Parm10
typedef Base::Parm11 | Parm11
typedef Base::Parm12 | Parm12
typedef Base::Parm13 | Parm13
typedef Base::Parm14 | Parm14
typedef Base::Parm15 | Parm15

Public Member Functions

MemFunHandler (const PointerToObj &pObj, PointerToMemFn pMemFn)
virtual MemFunHandler * | DoClone () const
ResultType operator() ()
ResultType | operator() (Parm1 p1)
ResultType | operator() (Parm1 p1, Parm2 p2)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
ResultType | operator() (Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)

Detailed Description

template<class ParentFunctor, typename PointerToObj, typename PointerToMemFn>
class Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >

Definition at line 1049 of file Functor.h.

The documentation for this class was generated from the following file:
  • Functor.h
Generated on Sat Jul 7 15:12:00 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::MostDerived< NullType, T > Struct Template Reference

Loki::TL::MostDerived< NullType, T >

Loki::TL::MostDerived< NullType, T > Struct Template Reference

List of all members.

Public Types

typedef T Result

Detailed Description

template<class T>
struct Loki::TL::MostDerived< NullType, T >

Definition at line 409 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::MostDerived< Typelist< Head, Tail >, T > Struct Template Reference

Loki::TL::MostDerived< Typelist< Head, Tail >, T >

Loki::TL::MostDerived< Typelist< Head, Tail >, T > Struct Template Reference

List of all members.

Public Types

typedef Select< SuperSubclass<
Candidate, Head >::value,
Head, Candidate >::Result 		Result

Detailed Description

template<class Head, class Tail, class T>
struct Loki::TL::MostDerived< Typelist< Head, Tail >, T >

Definition at line 415 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Mutex Class Reference

Loki::Mutex

Loki::Mutex Class Reference
[Threading]

#include <Threads.h>

List of all members.

Public Member Functions

Mutex ()
~Mutex ()
void | Lock ()
void | Unlock ()

Detailed Description

A simple and portable Mutex. A default policy class for locking objects.

Definition at line 165 of file Threads.h.

The documentation for this class was generated from the following file:
  • Threads.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::nameof_type< T > Struct Template Reference

Loki::TL::nameof_type

Loki::TL::nameof_type< T > Struct Template Reference

List of all members.

Public Member Functions

const char * operator() ()

Detailed Description

template<typename T>
struct Loki::TL::nameof_type< T >

Definition at line 50 of file DataGenerators.h.

The documentation for this struct was generated from the following file:
  • DataGenerators.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NeverCreate Class Reference

Loki::NeverCreate

Loki::NeverCreate Class Reference
[Creation policies]

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

#include <CachedFactory.h>

List of all members.

Protected Member Functions

bool | canCreate ()
void | onCreate ()
void | onDestroy ()
const char * | name ()

Classes

struct | Exception

Detailed Description

Never allows creation. Testing purposes only.

Using this policy will throw an exception.

Definition at line 108 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NeverCreate::Exception Struct Reference

Loki::NeverCreate::Exception

Loki::NeverCreate::Exception Struct Reference

List of all members.

Public Member Functions

const char * what () const throw ()

Detailed Description

Definition at line 111 of file CachedFactory.h.

The documentation for this struct was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NeverReset< P > Class Template Reference

Loki::NeverReset

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

#include <StrongPtr.h>

List of all members.

Public Member Functions

bool | OnReleaseAll (bool) const
bool | OnResetAll (bool) const

Detailed Description

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

Implementation of the ResetPolicy used by StrongPtr. It forbids reset and release under any circumstance.

Definition at line 289 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NoCheck< P > Struct Template Reference

Loki::NoCheck

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

#include <SmartPtr.h>

List of all members.

Public Member Functions

NoCheck ()
template<class P1>
NoCheck (const NoCheck< P1 > &)

Static Public Member Functions

static void | OnDefault (const P &)
static void | OnInit (const P &)
static void | OnDereference (const P &)
static void | Swap (NoCheck &)

Detailed Description

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

Implementation of the CheckingPolicy used by SmartPtr Well, it's clear what it does :o)

Definition at line 803 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NoCopy< P > Class Template Reference

Loki::NoCopy

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

#include <SmartPtr.h>

List of all members.

Public Types

enum

Public Member Functions

NoCopy ()
template<class P1>
NoCopy (const NoCopy< P1 > &)

Static Public Member Functions

static P | Clone (const P &)
static bool | Release (const P &)
static void | Swap (NoCopy &)

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

Definition at line 728 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NoDestroy< T > Struct Template Reference

Loki::NoDestroy

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

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void | ScheduleDestruction (T *, atexit_pfn_t)
static void | OnDeadReference ()

Detailed Description

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

Implementation of the LifetimePolicy used by SingletonHolder Never destroys the object

Definition at line 517 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::NoDuplicates< NullType > Struct Template Reference

Loki::TL::NoDuplicates< NullType >

Loki::TL::NoDuplicates< NullType > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<>
struct Loki::TL::NoDuplicates< NullType >

Definition at line 300 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::NoDuplicates< Typelist< Head, Tail > > Struct Template Reference

Loki::TL::NoDuplicates< Typelist< Head, Tail > >

Loki::TL::NoDuplicates< Typelist< Head, Tail > > Struct Template Reference

List of all members.

Public Types

typedef Typelist< Head, L2 > Result

Detailed Description

template<class Head, class Tail>
struct Loki::TL::NoDuplicates< Typelist< Head, Tail > >

Definition at line 306 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NoStatisticPolicy Class Reference

Loki::NoStatisticPolicy

Loki::NoStatisticPolicy Class Reference
[Statistic policies]

Do nothing. More...

#include <CachedFactory.h>

List of all members.

Protected Member Functions

void | onDebug ()
void | onFetch ()
void | onRelease ()
void | onCreate ()
void | onDestroy ()
const char * | name ()

Detailed Description

Do nothing.

Should be used in release code for better performances

Definition at line 541 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NullPointerException Struct Reference

Loki::NullPointerException

Loki::NullPointerException Struct Reference
[Smart pointers]

#include <SmartPtr.h>

List of all members.

Public Member Functions

NullPointerException ()
const char * what () const throw ()

Detailed Description

Used by some implementations of the CheckingPolicy used by SmartPtr

Definition at line 908 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::NullType Class Reference

Loki::NullType

Loki::NullType Class Reference

Detailed Description

Definition at line 29 of file NullType.h.

The documentation for this class was generated from the following file:
  • NullType.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ObjScopeGuardImpl0< Obj, MemFun > Class Template Reference

Loki::ObjScopeGuardImpl0

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

#include <ScopeGuard.h>

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

[legend]
Collaboration diagram for Loki::ObjScopeGuardImpl0< Obj, MemFun >:

[legend]
List of all members.

Public Member Functions

~ObjScopeGuardImpl0 () throw ()
void | Execute ()

Static Public Member Functions

static ObjScopeGuardImpl0<
Obj, MemFun > 		MakeObjGuard (Obj &obj, MemFun memFun)

Protected Member Functions

ObjScopeGuardImpl0 (Obj &obj, MemFun memFun)

Protected Attributes

Obj & | obj_
MemFun | memFun_

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.

Definition at line 410 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > Class Template Reference

Loki::ObjScopeGuardImpl1

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

#include <ScopeGuard.h>

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

[legend]
Collaboration diagram for Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >:

[legend]
List of all members.

Public Member Functions

~ObjScopeGuardImpl1 () throw ()
void | Execute ()

Static Public Member Functions

static ObjScopeGuardImpl1<
Obj, MemFun, P1 > 		MakeObjGuard (Obj &obj, MemFun memFun, P1 p1)

Protected Member Functions

ObjScopeGuardImpl1 (Obj &obj, MemFun memFun, P1 p1)

Protected Attributes

Obj & | obj_
MemFun | memFun_
const P1 | p1_

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.

Definition at line 472 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > Class Template Reference

Loki::ObjScopeGuardImpl2

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

#include <ScopeGuard.h>

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

[legend]
Collaboration diagram for Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >:

[legend]
List of all members.

Public Member Functions

~ObjScopeGuardImpl2 () throw ()
void | Execute ()

Static Public Member Functions

static ObjScopeGuardImpl2<
Obj, MemFun, P1, P2 > 		MakeObjGuard (Obj &obj, MemFun memFun, P1 p1, P2 p2)

Protected Member Functions

ObjScopeGuardImpl2 (Obj &obj, MemFun memFun, P1 p1, P2 p2)

Protected Attributes

Obj & | obj_
MemFun | memFun_
const P1 | p1_
const P2 | p2_

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.

Definition at line 535 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > Class Template Reference

Loki::ObjScopeGuardImpl3

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

[legend]
Collaboration diagram for Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >:

[legend]
List of all members.

Public Member Functions

~ObjScopeGuardImpl3 () throw ()
void | Execute ()

Static Public Member Functions

static ObjScopeGuardImpl3<
Obj, MemFun, P1, P2, P3 > 		MakeObjGuard (Obj &obj, MemFun memFun, P1 p1, P2 p2, P3 p3)

Protected Member Functions

ObjScopeGuardImpl3 (Obj &obj, MemFun memFun, P1 p1, P2 p2, P3 p3)

Protected Attributes

Obj & | obj_
MemFun | memFun_
const P1 | p1_
const P2 | p2_
const P3 | p3_

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.

Definition at line 599 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::OpNewFactoryUnit< ConcreteProduct, Base > Class Template Reference

Loki::OpNewFactoryUnit

Loki::OpNewFactoryUnit< ConcreteProduct, Base > Class Template Reference

List of all members.

Public Types

typedef BaseProductList::Head | AbstractProduct

Public Member Functions

ConcreteProduct * | DoCreate (Type2Type< AbstractProduct >)

Protected Types

typedef BaseProductList::Tail | ProductList

Detailed Description

template<class ConcreteProduct, class Base>
class Loki::OpNewFactoryUnit< ConcreteProduct, Base >

Definition at line 85 of file AbstractFactory.h.

The documentation for this class was generated from the following file:
  • AbstractFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::OrderedStatic< L, T, Loki::NullType > Class Template Reference

Loki::OrderedStatic< L, T, Loki::NullType >

Loki::OrderedStatic< L, T, Loki::NullType > Class Template Reference

Inheritance diagram for Loki::OrderedStatic< L, T, Loki::NullType >:

[legend]
Collaboration diagram for Loki::OrderedStatic< L, T, Loki::NullType >:

[legend]
List of all members.

Public Member Functions

OrderedStatic ()
void createObject ()

Detailed Description

template<unsigned int L, class T>
class Loki::OrderedStatic< L, T, Loki::NullType >

Definition at line 155 of file OrderedStatic.h.

The documentation for this class was generated from the following file:
  • OrderedStatic.h
Generated on Sat Jul 7 15:12:22 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::OrderedStatic< L, T, Loki::Seq< P1 > > Class Template Reference

Loki::OrderedStatic< L, T, Loki::Seq< P1 > >

Loki::OrderedStatic< L, T, Loki::Seq< P1 > > Class Template Reference

Inheritance diagram for Loki::OrderedStatic< L, T, Loki::Seq< P1 > >:

[legend]
Collaboration diagram for Loki::OrderedStatic< L, T, Loki::Seq< P1 > >:

[legend]
List of all members.

Public Member Functions

OrderedStatic (P1 p)
void createObject ()

Detailed Description

template<unsigned int L, class T, typename P1>
class Loki::OrderedStatic< L, T, Loki::Seq< P1 > >

Definition at line 175 of file OrderedStatic.h.

The documentation for this class was generated from the following file:
  • OrderedStatic.h
Generated on Sat Jul 7 15:12:22 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::OrderedStatic< L, T, P1(*)() > Class Template Reference

Loki::OrderedStatic< L, T, P1(*)() >

Loki::OrderedStatic< L, T, P1(*)() > Class Template Reference

Inheritance diagram for Loki::OrderedStatic< L, T, P1(*)() >:

[legend]
Collaboration diagram for Loki::OrderedStatic< L, T, P1(*)() >:

[legend]
List of all members.

Public Types

typedef P1(*) | Func ()

Public Member Functions

OrderedStatic (Func p)
void | createObject ()

Detailed Description

template<unsigned int L, class T, typename P1>
class Loki::OrderedStatic< L, T, P1(*)() >

Definition at line 197 of file OrderedStatic.h.

The documentation for this class was generated from the following file:
  • OrderedStatic.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::OrderedStaticBase< T > Class Template Reference

Loki::Private::OrderedStaticBase

Loki::Private::OrderedStaticBase< T > Class Template Reference

Inheritance diagram for Loki::Private::OrderedStaticBase< T >:

[legend]
Collaboration diagram for Loki::Private::OrderedStaticBase< T >:

[legend]
List of all members.

Public Member Functions

T & | operator * ()
T * | operator-> ()

Protected Member Functions

OrderedStaticBase (unsigned int longevity)
virtual | ~OrderedStaticBase ()
void | SetLongevity (T *ptr)

Detailed Description

template<class T>
class Loki::Private::OrderedStaticBase< T >

Definition at line 54 of file OrderedStatic.h.

The documentation for this class was generated from the following file:
  • OrderedStatic.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::OrderedStaticCreatorFunc Class Reference

Loki::Private::OrderedStaticCreatorFunc

Loki::Private::OrderedStaticCreatorFunc Class Reference

Inheritance diagram for Loki::Private::OrderedStaticCreatorFunc:

[legend]
List of all members.

Protected Member Functions

OrderedStaticCreatorFunc ()
virtual ~OrderedStaticCreatorFunc ()

Detailed Description

Definition at line 36 of file OrderedStatic.h.

The documentation for this class was generated from the following files:
  • OrderedStatic.h
  • OrderedStatic.cpp
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::OrderedStaticManagerClass Class Reference

Loki::Private::OrderedStaticManagerClass

Loki::Private::OrderedStaticManagerClass Class Reference

List of all members.

Public Types

typedef void(OrderedStaticCreatorFunc::*) | Creator ()

Public Member Functions

OrderedStaticManagerClass ()
virtual | ~OrderedStaticManagerClass ()
void | createObjects ()
void | registerObject (unsigned int longevity, OrderedStaticCreatorFunc *, Creator)

Detailed Description

Definition at line 96 of file OrderedStatic.h.

The documentation for this class was generated from the following files:
  • OrderedStatic.h
  • OrderedStatic.cpp
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::PhoenixSingleton< T > Struct Template Reference

Loki::PhoenixSingleton

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

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void | ScheduleDestruction (T *, atexit_pfn_t pFun)
static void | OnDeadReference ()

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

Definition at line 370 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Pimpl< T, Pointer > Class Template Reference

Loki::Pimpl

Loki::Pimpl< T, Pointer > Class Template Reference
[Pimpl]

#include <Pimpl.h>

List of all members.

Public Types

typedef T | Impl

Public Member Functions

Pimpl ()
~Pimpl ()
T * | operator-> ()
T & | operator * ()
const T * | operator-> () const
const T & | operator * () const
Pointer & | wrapped ()
const Pointer & | wrapped () const

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

Definition at line 75 of file Pimpl.h.

The documentation for this class was generated from the following file:
  • Pimpl.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::PimplOf< T, Ptr > Struct Template Reference

Loki::PimplOf

Loki::PimplOf< T, Ptr > Struct Template Reference

List of all members.

Public Types

typedef T Impl
typedef Pimpl< ImplOf< T >,
Ptr< ImplOf< T > > > 		Type
typedef PimplOwner< ImplOf<
T >, Ptr< ImplOf< T > > > 		Owner

Detailed Description

template<class T, template< class > class Ptr = ConstPropPtr>
struct Loki::PimplOf< T, Ptr >

Definition at line 165 of file Pimpl.h.

The documentation for this struct was generated from the following file:
  • Pimpl.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: PImplOf Class Reference

PImplOf Class Reference
[Pimpl]

#include <Pimpl.h>

Detailed Description

Convenience template which uses ImplOf as implementation structure

Definition at line 152 of file Pimpl.h.

The documentation for this class was generated from the following file:
  • Pimpl.h
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::PimplOwner< T, Pointer > Struct Template Reference

Loki::PimplOwner

Loki::PimplOwner< T, Pointer > Struct Template Reference

List of all members.

Public Attributes

Pimpl< T, Pointer > d

Detailed Description

template<class T, typename Pointer = ConstPropPtr<T>>
struct Loki::PimplOwner< T, Pointer >

Definition at line 137 of file Pimpl.h.

The documentation for this struct was generated from the following file:
  • Pimpl.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::PrintfState< Device, Char > Struct Template Reference

Loki::PrintfState

Loki::PrintfState< Device, Char > Struct Template Reference

List of all members.

Public Member Functions

PrintfState (Device dev, const Char *format)
~PrintfState ()
PrintfState & | operator() (bool par)
PrintfState & | operator() (char par)
PrintfState & | operator() (signed char par)
PrintfState & | operator() (unsigned char par)
PrintfState & | operator() (signed short par)
PrintfState & | operator() (unsigned short par)
PrintfState & | operator() (signed int par)
PrintfState & | operator() (signed long par)
PrintfState & | operator() (unsigned int par)
PrintfState & | operator() (unsigned long i)
PrintfState & | operator() (void *n)
PrintfState & | operator() (double n)
PrintfState & | operator() (long double n)
PrintfState & | operator() (int *pi)
PrintfState & | operator() (short *pi)
PrintfState & | operator() (long *pi)
PrintfState & | operator() (const std::string &stdstr)
PrintfState & | operator() (const char *const s)
PrintfState & | operator() (const void *const p)
operator int () const

Detailed Description

template<class Device, class Char>
struct Loki::PrintfState< Device, Char >

Definition at line 88 of file SafeFormat.h.

The documentation for this struct was generated from the following file:
  • SafeFormat.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::PropagateConst< T > Class Template Reference

Loki::PropagateConst

Loki::PropagateConst< T > Class Template Reference

#include <ConstPolicy.h>

List of all members.

Public Types

typedef const T Type

Detailed Description

template<class T>
class Loki::PropagateConst< T >

Propagate constness of pointed or referred object.

Definition at line 49 of file ConstPolicy.h.

The documentation for this class was generated from the following file:
  • ConstPolicy.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::PrototypeFactoryUnit< ConcreteProduct, Base > Class Template Reference

Loki::PrototypeFactoryUnit

Loki::PrototypeFactoryUnit< ConcreteProduct, Base > Class Template Reference

List of all members.

Public Types

typedef BaseProductList::Head | AbstractProduct

Public Member Functions

PrototypeFactoryUnit (AbstractProduct *p=0)
template<class U>
void | GetPrototype (U *&p)
template<class U>
void | SetPrototype (U *pObj)
AbstractProduct * DoCreate (Type2Type< AbstractProduct >)

Protected Types

typedef BaseProductList::Tail | ProductList

Detailed Description

template<class ConcreteProduct, class Base>
class Loki::PrototypeFactoryUnit< ConcreteProduct, Base >

Definition at line 111 of file AbstractFactory.h.

The documentation for this class was generated from the following file:
  • AbstractFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RateLimitedCreation Class Reference

Loki::RateLimitedCreation

Loki::RateLimitedCreation Class Reference
[Creation policies]

Limit in rate. More...

#include <CachedFactory.h>

List of all members.

Public Member Functions

void | setRate (unsigned maxCreation, unsigned byTime)

Protected Member Functions

RateLimitedCreation ()
bool | canCreate ()
void | onCreate ()
void | onDestroy ()
const char * | name ()

Classes

struct | Exception

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.

Definition at line 162 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RateLimitedCreation::Exception Struct Reference

Loki::RateLimitedCreation::Exception

Loki::RateLimitedCreation::Exception Struct Reference

List of all members.

Public Member Functions

const char * what () const throw ()

Detailed Description

Definition at line 208 of file CachedFactory.h.

The documentation for this struct was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RefCounted< P > Class Template Reference

Loki::RefCounted

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

#include <SmartPtr.h>

List of all members.

Public Types

enum

Public Member Functions

RefCounted ()
RefCounted (const RefCounted &rhs)
template<typename P1>
RefCounted (const RefCounted< P1 > &rhs)
P | Clone (const P &val)
bool | Release (const P &)
void | Swap (RefCounted &rhs)

Detailed Description

template<class P>
class Loki::RefCounted< P >

Implementation of the OwnershipPolicy used by SmartPtr Provides a classic external reference counting implementation

Definition at line 429 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


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

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RefCountedMTAdj< ThreadingModel, MX > Struct Template Reference

Loki::RefCountedMTAdj

Loki::RefCountedMTAdj< ThreadingModel, MX > Struct Template Reference

Classes

class RefCountedMT

Detailed Description

template<template< class, class > class ThreadingModel, class MX = ::Loki::Mutex>
struct Loki::RefCountedMTAdj< ThreadingModel, MX >

Definition at line 492 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > Class Template Reference

Loki::RefCountedMTAdj::RefCountedMT

Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P > Class Template Reference

List of all members.

Public Types

enum

Public Member Functions

RefCountedMT ()
RefCountedMT (const RefCountedMT &rhs)
template<typename P1>
RefCountedMT (const RefCountedMT< P1 > &rhs)
P | Clone (const P &val)
bool | Release (const P &)
void | Swap (RefCountedMT &rhs)

Detailed Description

template<template< class, class > class ThreadingModel, class MX = ::Loki::Mutex>
template<class P>
class Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >

Definition at line 495 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RefLinked< P > Class Template Reference

Loki::RefLinked

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

#include <SmartPtr.h>

Inheritance diagram for Loki::RefLinked< P >:

[legend]
Collaboration diagram for Loki::RefLinked< P >:

[legend]
List of all members.

Public Member Functions

RefLinked ()
template<class P1>
RefLinked (const RefLinked< P1 > &rhs)
bool | Release (const P &)
template<class P1>
bool | Merge (RefLinked< P1 > &rhs)

Static Public Member Functions

static P | Clone (const P &val)

Detailed Description

template<class P>
class Loki::RefLinked< P >

Implementation of the OwnershipPolicy used by SmartPtr Implements reference linking

Definition at line 659 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::RefLinkedBase Class Reference

Loki::Private::RefLinkedBase

Loki::Private::RefLinkedBase Class Reference

Inheritance diagram for Loki::Private::RefLinkedBase:

[legend]
Collaboration diagram for Loki::Private::RefLinkedBase:

[legend]
List of all members.

Public Types

enum

Public Member Functions

RefLinkedBase ()
RefLinkedBase (const RefLinkedBase &rhs)
bool | Release ()
void | Swap (RefLinkedBase &rhs)
bool | Merge (RefLinkedBase &rhs)

Detailed Description

Definition at line 631 of file SmartPtr.h.

Member Function Documentation

bool Loki::Private::RefLinkedBase::Merge ( RefLinkedBase & rhs )

Definition at line 253 of file SmartPtr.cpp.

References next_, and prev_.

Referenced by Loki::RefLinked< P >::Merge().

The documentation for this class was generated from the following files:
  • SmartPtr.h
  • SmartPtr.cpp
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RefToValue< T > Class Template Reference

Loki::RefToValue

Loki::RefToValue< T > Class Template Reference
[Smart pointers]

#include <RefToValue.h>

List of all members.

Public Member Functions

RefToValue (T &ref)
RefToValue (const RefToValue &rhs)
operator T & () const

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

Definition at line 31 of file RefToValue.h.

The documentation for this class was generated from the following file:
  • RefToValue.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::RegisterOnCreate< T > Struct Template Reference

Loki::Private::RegisterOnCreate

Loki::Private::RegisterOnCreate< T > Struct Template Reference

List of all members.

Public Member Functions

RegisterOnCreate ()

Detailed Description

template<class T>
struct Loki::Private::RegisterOnCreate< T >

Definition at line 47 of file Register.h.

The documentation for this struct was generated from the following file:
  • Register.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::RegisterOnCreateElement< T > Struct Template Reference

Loki::Private::RegisterOnCreateElement

Loki::Private::RegisterOnCreateElement< T > Struct Template Reference

List of all members.

Public Attributes

RegisterOnCreate< T > registerObj

Detailed Description

template<class T>
struct Loki::Private::RegisterOnCreateElement< T >

Definition at line 59 of file Register.h.

The documentation for this struct was generated from the following file:
  • Register.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RegisterOnCreateSet< ElementList > Class Template Reference

Loki::RegisterOnCreateSet

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

#include <Register.h>

Inheritance diagram for Loki::RegisterOnCreateSet< ElementList >:

[legend]
Collaboration diagram for Loki::RegisterOnCreateSet< ElementList >:

[legend]

Detailed Description

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

Implements a generic register class which registers classes of a typelist

Usage
see test/Register

Definition at line 82 of file Register.h.

The documentation for this class was generated from the following file:
  • Register.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RejectNull< P > Struct Template Reference

Loki::RejectNull

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

#include <SmartPtr.h>

List of all members.

Public Member Functions

RejectNull ()
template<class P1>
RejectNull (const RejectNull< P1 > &)
void | OnDereference (P val)
void | OnDereference (P val) const
void | Swap (RejectNull &)

Static Public Member Functions

static void | OnInit (P)
static void | OnDefault (P)

Detailed Description

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

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer before dereference

Definition at line 973 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RejectNullStatic< P > Struct Template Reference

Loki::RejectNullStatic

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

#include <SmartPtr.h>

List of all members.

Public Member Functions

RejectNullStatic ()
template<class P1>
RejectNullStatic (const RejectNullStatic< P1 > &)
template<class P1>
RejectNullStatic (const NoCheck< P1 > &)
template<class P1>
RejectNullStatic (const AssertCheck< P1 > &)
template<class P1>
RejectNullStatic (const AssertCheckStrict< P1 > &)

Static Public Member Functions

static void | OnDefault (const P &)
static void | OnInit (const P &val)
static void | OnDereference (const P &val)
static void | Swap (RejectNullStatic &)

Detailed Description

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

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer upon initialization and before dereference

Definition at line 925 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RejectNullStrict< P > Struct Template Reference

Loki::RejectNullStrict

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

#include <SmartPtr.h>

List of all members.

Public Member Functions

RejectNullStrict ()
template<class P1>
RejectNullStrict (const RejectNullStrict< P1 > &)
template<class P1>
RejectNullStrict (const RejectNull< P1 > &)
void | OnDereference (P val)
void | OnDereference (P val) const
void | Swap (RejectNullStrict &)

Static Public Member Functions

static void | OnInit (P val)

Detailed Description

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

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer upon initialization and before dereference

Definition at line 1007 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Replace< NullType, T, U > Struct Template Reference

Loki::TL::Replace< NullType, T, U >

Loki::TL::Replace< NullType, T, U > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<class T, class U>
struct Loki::TL::Replace< NullType, T, U >

Definition at line 326 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Replace< Typelist< Head, Tail >, T, U > Struct Template Reference

Loki::TL::Replace< Typelist< Head, Tail >, T, U >

Loki::TL::Replace< Typelist< Head, Tail >, T, U > Struct Template Reference

List of all members.

Public Types

typedef Typelist< Head, typename
Replace< Tail, T, U >::Result > 		Result

Detailed Description

template<class Head, class Tail, class T, class U>
struct Loki::TL::Replace< Typelist< Head, Tail >, T, U >

Definition at line 338 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Replace< Typelist< T, Tail >, T, U > Struct Template Reference

Loki::TL::Replace< Typelist< T, Tail >, T, U >

Loki::TL::Replace< Typelist< T, Tail >, T, U > Struct Template Reference

List of all members.

Public Types

typedef Typelist< U, Tail > Result

Detailed Description

template<class T, class Tail, class U>
struct Loki::TL::Replace< Typelist< T, Tail >, T, U >

Definition at line 332 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::ReplaceAll< NullType, T, U > Struct Template Reference

Loki::TL::ReplaceAll< NullType, T, U >

Loki::TL::ReplaceAll< NullType, T, U > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<class T, class U>
struct Loki::TL::ReplaceAll< NullType, T, U >

Definition at line 356 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U > Struct Template Reference

Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U >

Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U > Struct Template Reference

List of all members.

Public Types

typedef Typelist< Head, typename
ReplaceAll< Tail, T, U
>::Result > 		Result

Detailed Description

template<class Head, class Tail, class T, class U>
struct Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U >

Definition at line 368 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U > Struct Template Reference

Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U >

Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U > Struct Template Reference

List of all members.

Public Types

typedef Typelist< U, typename
ReplaceAll< Tail, T, U
>::Result > 		Result

Detailed Description

template<class T, class Tail, class U>
struct Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U >

Definition at line 362 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Reverse< NullType > Struct Template Reference

Loki::TL::Reverse< NullType >

Loki::TL::Reverse< NullType > Struct Template Reference

List of all members.

Public Types

typedef NullType Result

Detailed Description

template<>
struct Loki::TL::Reverse< NullType >

Definition at line 386 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::Reverse< Typelist< Head, Tail > > Struct Template Reference

Loki::TL::Reverse< Typelist< Head, Tail > >

Loki::TL::Reverse< Typelist< Head, Tail > > Struct Template Reference

List of all members.

Public Types

typedef Append< typename Reverse<
Tail >::Result, Head >::Result 		Result

Detailed Description

template<class Head, class Tail>
struct Loki::TL::Reverse< Typelist< Head, Tail > >

Definition at line 392 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RimplOf< T, UsedPimpl > Struct Template Reference

Loki::RimplOf

Loki::RimplOf< T, UsedPimpl > Struct Template Reference

List of all members.

Public Types

typedef UsedPimpl::Impl & | Type

Classes

class | Owner

Detailed Description

template<class T, class UsedPimpl = typename PimplOf<T>::Type>
struct Loki::RimplOf< T, UsedPimpl >

Definition at line 178 of file Pimpl.h.

The documentation for this struct was generated from the following file:
  • Pimpl.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::RimplOf< T, UsedPimpl >::Owner Class Reference

Loki::RimplOf::Owner

Loki::RimplOf< T, UsedPimpl >::Owner Class Reference

List of all members.

Public Member Functions

Owner ()

Public Attributes

Type d

Detailed Description

template<class T, class UsedPimpl = typename PimplOf<T>::Type>
class Loki::RimplOf< T, UsedPimpl >::Owner

Definition at line 182 of file Pimpl.h.

The documentation for this class was generated from the following file:
  • Pimpl.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ScopeGuardImpl0< F > Class Template Reference

Loki::ScopeGuardImpl0

Loki::ScopeGuardImpl0< F > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl0< F >:

[legend]
Collaboration diagram for Loki::ScopeGuardImpl0< F >:

[legend]
List of all members.

Public Member Functions

~ScopeGuardImpl0 () throw ()
void | Execute ()

Static Public Member Functions

static ScopeGuardImpl0< F > | MakeGuard (F fun)

Protected Member Functions

ScopeGuardImpl0 (F fun)

Protected Attributes

F | fun_

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.

Definition at line 108 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ScopeGuardImpl1< F, P1 > Class Template Reference

Loki::ScopeGuardImpl1

Loki::ScopeGuardImpl1< F, P1 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl1< F, P1 >:

[legend]
Collaboration diagram for Loki::ScopeGuardImpl1< F, P1 >:

[legend]
List of all members.

Public Member Functions

~ScopeGuardImpl1 () throw ()
void | Execute ()

Static Public Member Functions

static ScopeGuardImpl1< F,
P1 > 		MakeGuard (F fun, P1 p1)

Protected Member Functions

ScopeGuardImpl1 (F fun, P1 p1)

Protected Attributes

F | fun_
const P1 | p1_

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.

Definition at line 155 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ScopeGuardImpl2< F, P1, P2 > Class Template Reference

Loki::ScopeGuardImpl2

Loki::ScopeGuardImpl2< F, P1, P2 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl2< F, P1, P2 >:

[legend]
Collaboration diagram for Loki::ScopeGuardImpl2< F, P1, P2 >:

[legend]
List of all members.

Public Member Functions

~ScopeGuardImpl2 () throw ()
void | Execute ()

Static Public Member Functions

static ScopeGuardImpl2< F,
P1, P2 > 		MakeGuard (F fun, P1 p1, P2 p2)

Protected Member Functions

ScopeGuardImpl2 (F fun, P1 p1, P2 p2)

Protected Attributes

F | fun_
const P1 | p1_
const P2 | p2_

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.

Definition at line 203 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ScopeGuardImpl3< F, P1, P2, P3 > Class Template Reference

Loki::ScopeGuardImpl3

Loki::ScopeGuardImpl3< F, P1, P2, P3 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl3< F, P1, P2, P3 >:

[legend]
Collaboration diagram for Loki::ScopeGuardImpl3< F, P1, P2, P3 >:

[legend]
List of all members.

Public Member Functions

~ScopeGuardImpl3 () throw ()
void | Execute ()

Static Public Member Functions

static ScopeGuardImpl3< F,
P1, P2, P3 > 		MakeGuard (F fun, P1 p1, P2 p2, P3 p3)

Protected Member Functions

ScopeGuardImpl3 (F fun, P1 p1, P2 p2, P3 p3)

Protected Attributes

F | fun_
const P1 | p1_
const P2 | p2_
const P3 | p3_

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.

Definition at line 252 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > Class Template Reference

Loki::ScopeGuardImpl4

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

[legend]
Collaboration diagram for Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >:

[legend]
List of all members.

Public Member Functions

~ScopeGuardImpl4 () throw ()
void | Execute ()

Static Public Member Functions

static ScopeGuardImpl4< F,
P1, P2, P3, P4 > 		MakeGuard (F fun, P1 p1, P2 p2, P3 p3, P4 p4)

Protected Member Functions

ScopeGuardImpl4 (F fun, P1 p1, P2 p2, P3 p3, P4 p4)

Protected Attributes

F | fun_
const P1 | p1_
const P2 | p2_
const P3 | p3_
const P4 | p4_

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.

Definition at line 302 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > Class Template Reference

Loki::ScopeGuardImpl5

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

[legend]
Collaboration diagram for Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >:

[legend]
List of all members.

Public Member Functions

~ScopeGuardImpl5 () throw ()
void | Execute ()

Static Public Member Functions

static ScopeGuardImpl5< F,
P1, P2, P3, P4, P5 > 		MakeGuard (F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)

Protected Member Functions

ScopeGuardImpl5 (F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)

Protected Attributes

F | fun_
const P1 | p1_
const P2 | p2_
const P3 | p3_
const P4 | p4_
const P5 | p5_

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.

Definition at line 355 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:06 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::ScopeGuardImplBase Class Reference

Loki::ScopeGuardImplBase

Loki::ScopeGuardImplBase Class Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImplBase:

[legend]
List of all members.

Public Member Functions

ScopeGuardImplBase () throw ()
void | Dismiss () const throw ()

Protected Member Functions

~ScopeGuardImplBase ()
ScopeGuardImplBase (const ScopeGuardImplBase &other) throw ()
Copy-constructor takes over responsibility from other ScopeGuard.

Static Protected Member Functions

template<typename J>
static void | SafeExecute (J &j) throw ()

Protected Attributes

bool | dismissed_

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

Definition at line 43 of file ScopeGuard.h.

The documentation for this class was generated from the following file:
  • ScopeGuard.h
Generated on Sat Jul 7 15:12:05 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Select< flag, T, U > Struct Template Reference

Loki::Select

Loki::Select< flag, T, U > Struct Template Reference

List of all members.

Public Types

typedef T Result

Detailed Description

template<bool flag, typename T, typename U>
struct Loki::Select< flag, T, U >

Definition at line 60 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Select< false, T, U > Struct Template Reference

Loki::Select< false, T, U >

Loki::Select< false, T, U > Struct Template Reference

List of all members.

Public Types

typedef U Result

Detailed Description

template<typename T, typename U>
struct Loki::Select< false, T, U >

Definition at line 65 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > Struct Template Reference

Loki::Seq

Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > Struct Template Reference

List of all members.

Public Types

typedef Typelist< T01, TailResult > Type

Detailed Description

template<class T01 = NullType, class T02 = NullType, class T03 = NullType, class T04 = NullType, class T05 = NullType, class T06 = NullType, class T07 = NullType, class T08 = NullType, class T09 = NullType, class T10 = NullType, class T11 = NullType, class T12 = NullType, class T13 = NullType, class T14 = NullType, class T15 = NullType, class T16 = NullType, class T17 = NullType, class T18 = NullType, class T19 = NullType, class T20 = NullType>
struct Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 >

Definition at line 30 of file Sequence.h.

The documentation for this struct was generated from the following file:
  • Sequence.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Seq<> Struct Template Reference

Loki::Seq<>

Loki::Seq<> Struct Template Reference

List of all members.

Public Types

typedef NullType Type

Detailed Description

template<>
struct Loki::Seq<>

Definition at line 41 of file Sequence.h.

The documentation for this struct was generated from the following file:
  • Sequence.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SimplePointer< AbstractProduct > Class Template Reference

Loki::SimplePointer

Loki::SimplePointer< AbstractProduct > Class Template Reference
[Encapsulation policies]

No encaspulation : returns the pointer. More...

#include <CachedFactory.h>

List of all members.

Protected Types

typedef AbstractProduct * | ProductReturn

Protected Member Functions

ProductReturn | encapsulate (AbstractProduct *pProduct)
AbstractProduct * | release (ProductReturn &pProduct)
const char * | name ()

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.

Definition at line 72 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:43 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SimpleStatisticPolicy Class Reference

Loki::SimpleStatisticPolicy

Loki::SimpleStatisticPolicy Class Reference
[Statistic policies]

Simple statistics. More...

#include <CachedFactory.h>

List of all members.

Public Member Functions

unsigned | getCreated ()
unsigned | getFetched ()
unsigned | getHit ()
unsigned | getMissed ()
unsigned | getAllocated ()
unsigned | getOut ()
unsigned | getDestroyed ()

Protected Member Functions

SimpleStatisticPolicy ()
void | onDebug ()
void | onFetch ()
void | onRelease ()
void | onCreate ()
void | onDestroy ()
const char * | name ()

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

Definition at line 567 of file CachedFactory.h.

The documentation for this class was generated from the following file:
  • CachedFactory.h
Generated on Sat Jul 7 15:11:44 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SingleThreaded< Host, MutexPolicy > Class Template Reference

Loki::SingleThreaded

Loki::SingleThreaded< Host, MutexPolicy > Class Template Reference
[Threading]

#include <Threads.h>

List of all members.

Public Types

typedef Host | VolatileType
typedef int | IntType

Static Public Member Functions

static IntType | AtomicAdd (volatile IntType &lval, IntType val)
static IntType | AtomicSubtract (volatile IntType &lval, IntType val)
static IntType | AtomicMultiply (volatile IntType &lval, IntType val)
static IntType | AtomicDivide (volatile IntType &lval, IntType val)
static IntType | AtomicIncrement (volatile IntType &lval)
static IntType | AtomicDecrement (volatile IntType &lval)
static void | AtomicAssign (volatile IntType &lval, IntType val)
static void | AtomicAssign (IntType &lval, volatile IntType &val)

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

Definition at line 201 of file Threads.h.

The documentation for this class was generated from the following file:
  • Threads.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


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

Loki::SingleThreaded::Lock

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

#include <Threads.h>

List of all members.

Public Member Functions

Lock ()
Lock (const SingleThreaded &)
Lock (const SingleThreaded *)

Detailed Description

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

Dummy Lock class

Definition at line 206 of file Threads.h.

The documentation for this struct was generated from the following file:
  • Threads.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


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

Loki::Singleton

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

Definition at line 864 of file Singleton.h.

The documentation for this class was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


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

Loki::LongevityLifetime::SingletonFixedLongevity

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.

Public Member Functions

virtual | ~SingletonFixedLongevity ()

Static Public Member Functions

static void | ScheduleDestruction (T *pObj, atexit_pfn_t pFun)
static void | OnDeadReference ()

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

Definition at line 550 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:34 2007 for Loki by doxygen 1.5.1-p1


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

Loki::SingletonHolder

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

Definition at line 725 of file Singleton.h.

The documentation for this class was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SingletonWithLongevity< T > Struct Template Reference

Loki::SingletonWithLongevity

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

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void | ScheduleDestruction (T *pObj, atexit_pfn_t pFun)
static void | OnDeadReference ()

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.

Definition at line 496 of file Singleton.h.

The documentation for this struct was generated from the following file:
  • Singleton.h
Generated on Sat Jul 7 15:12:07 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::sizeof_type< T > Struct Template Reference

Loki::TL::sizeof_type

Loki::TL::sizeof_type< T > Struct Template Reference

List of all members.

Public Member Functions

size_t operator() ()

Detailed Description

template<typename T>
struct Loki::TL::sizeof_type< T >

Definition at line 58 of file DataGenerators.h.

The documentation for this struct was generated from the following file:
  • DataGenerators.h
Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SmallObjAllocator Class Reference

Loki::SmallObjAllocator

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.

Definition at line 86 of file SmallObj.h.

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.

Definition at line 1051 of file SmallObj.cpp.

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.

Definition at line 1069 of file SmallObj.cpp.

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.

Definition at line 1100 of file SmallObj.cpp.

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

Definition at line 1135 of file SmallObj.cpp.

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

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.

Definition at line 1159 of file SmallObj.cpp.

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

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.

Definition at line 1079 of file SmallObj.cpp.

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:

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.

Definition at line 1190 of file SmallObj.cpp.

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:

The documentation for this class was generated from the following files:
  • SmallObj.h
  • SmallObj.cpp
Generated on Sat Jul 7 15:12:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference

Loki::SmallObject

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.

Public Member Functions

virtual ~SmallObject ()

Protected Member Functions

SmallObject (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::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.

Definition at line 594 of file SmallObj.h.

The documentation for this class was generated from the following file:
  • SmallObj.h
Generated on Sat Jul 7 15:12:12 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference

Loki::SmallObjectBase

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.

Protected Member Functions

SmallObjectBase (void)
SmallObjectBase (const SmallObjectBase &)
SmallObjectBase & | operator= (const SmallObjectBase &)
~SmallObjectBase ()

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

  • LongevityLifetime::DieAsSmallObjectParent / LongevityLifetime::DieAsSmallObjectChild
  • SingletonWithLongevity
  • FollowIntoDeath (not supported by MSVC 7.1)
  • NoDestroy

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
  • LongevityLifetime: The Small-Object has LongevityLifetime::DieAsSmallObjectParent policy and the Singleton hosting the Small-Object has LongevityLifetime::DieAsSmallObjectChild. The child lifetime has a hard coded SetLongevity lifetime which is shorter than the lifetime of the parent, thus the child dies before the parent.

  • Both Small-Object and Singleton use SingletonWithLongevity policy. The longevity level for the singleton must be lower than that for the Small-Object. This is why the AllocatorSingleton's GetLongevity function returns the highest value.

  • FollowIntoDeath lifetime: The Small-Object has FollowIntoDeath::With<LIFETIME>::AsMasterLiftime policy and the Singleton has FollowIntoDeath::AfterMaster<MASTERSINGLETON>::IsDestroyed policy, where you could choose the LIFETIME.

  • Both Small-Object and Singleton use NoDestroy policy. Since neither is ever destroyed, the destruction order does not matter. Note: you will get memory leaks!

  • The Small-Object has NoDestroy policy but the Singleton has SingletonWithLongevity policy. Note: you will get memory leaks!

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

Examples:
  • test/SmallObj/SmallSingleton.cpp
  • test/Singleton/Dependencies.cpp

Definition at line 436 of file SmallObj.h.

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.

Definition at line 445 of file SmallObj.h.

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.

Definition at line 495 of file SmallObj.h.

The documentation for this class was generated from the following file:
  • SmallObj.h
Generated on Sat Jul 7 15:12:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference

Loki::SmallValueObject

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.

Protected Member Functions

SmallValueObject (void)
SmallValueObject (const SmallValueObject &)
SmallValueObject & operator= (const SmallValueObject &)
~SmallValueObject ()

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.

Definition at line 630 of file SmallObj.h.

The documentation for this class was generated from the following file:
  • SmallObj.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > Class Template Reference

Loki::SmartPointer

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.

Protected Types

typedef CallBackSP | ProductReturn

Protected Member Functions

SmartPointer ()
virtual | ~SmartPointer ()
ProductReturn | encapsulate (AbstractProduct *pProduct)
AbstractProduct * | release (ProductReturn &pProduct)
const char * | name ()

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.

Definition at line 165 of file SPCachedFactory.h.

The documentation for this class was generated from the following file:
  • SPCachedFactory.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Class Template Reference

Loki::SmartPtr

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

#include <SmartPtr.h>

List of all members.

Public Types

typedef ConstnessPolicy< T
>::Type * 		ConstPointerType
typedef ConstnessPolicy< T
>::Type & 		ConstReferenceType
typedef SP::PointerType | PointerType
typedef SP::StoredType | StoredType
typedef SP::ReferenceType | ReferenceType
typedef Select< OP::destructiveCopy,
SmartPtr, const SmartPtr
>::Result 		CopyArg

Public Member Functions

SmartPtr ()
SmartPtr (ExplicitArg p)
SmartPtr (ImplicitArg p)
SmartPtr (CopyArg &rhs)
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
SmartPtr (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
SmartPtr (SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
SmartPtr (RefToValue< SmartPtr > rhs)
operator RefToValue ()
SmartPtr & | operator= (CopyArg &rhs)
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
SmartPtr & | operator= (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
SmartPtr & | operator= (SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
void | Swap (SmartPtr &rhs)
~SmartPtr ()
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
bool | Merge (SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
PointerType operator-> ()
ConstPointerType | operator-> () const
ReferenceType operator * ()
ConstReferenceType | operator * () const
bool | operator! () const
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
bool | operator== (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) const
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
bool | operator!= (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) const
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
bool | operator< (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs) const
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
bool | operator> (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
bool | operator<= (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
template<typename T1, template< class > class OP1, class CP1, template< class > class KP1, template< class > class SP1, template< class > class CNP1>
bool | operator>= (const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > &rhs)
operator unspecified_boolean_type () const
operator AutomaticConversionResult () const

Static Public Member Functions

static T * | GetPointer (const SmartPtr &sp)

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:
  • Release() returns a boolean saying if that was the last release so the pointer can be deleted by the StoragePolicy
  • IsUnique() was removed

Definition at line 1107 of file SmartPtr.h.

The documentation for this class was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Struct Template Reference

Loki::SmartPtrDef

Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Struct Template Reference

List of all members.

Public Types

typedef SmartPtr< T, OwnershipPolicy,
ConversionPolicy, CheckingPolicy,
StoragePolicy, ConstnessPolicy > 		type

Detailed Description

template<typename T, template< class > class OwnershipPolicy = RefCounted, class ConversionPolicy = DisallowConversion, template< class > class CheckingPolicy = AssertCheck, template< class > class StoragePolicy = DefaultSPStorage, template< class > class ConstnessPolicy = ::Loki::DontPropagateConst>
struct Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >

Definition at line 1065 of file SmartPtr.h.

The documentation for this struct was generated from the following file:
  • SmartPtr.h
Generated on Sat Jul 7 15:12:16 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::StaticCaster< To, From > Struct Template Reference

Loki::StaticCaster

Loki::StaticCaster< To, From > Struct Template Reference

List of all members.

Static Public Member Functions

static To & Cast (From &obj)

Detailed Description

template<class To, class From>
struct Loki::StaticCaster< To, From >

Definition at line 197 of file MultiMethods.h.

The documentation for this struct was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType > Class Template Reference

Loki::StaticDispatcher

Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType > Class Template Reference

List of all members.

Static Public Member Functions

static ResultType Go (BaseLhs &lhs, BaseRhs &rhs, Executor exec)

Detailed Description

template<class Executor, class BaseLhs, class TypesLhs, bool symmetric = true, class BaseRhs = BaseLhs, class TypesRhs = TypesLhs, typename ResultType = void>
class Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType >

Definition at line 75 of file MultiMethods.h.

The documentation for this class was generated from the following file:
  • MultiMethods.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


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

Loki::StrongPtr

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

#include <StrongPtr.h>

List of all members.

Public Types

typedef OwnershipPolicy | OP
typedef T * | StoredType
typedef T * | PointerType
typedef T & | ReferenceType
typedef ConstnessPolicy< T
>::Type * 		ConstPointerType
typedef ConstnessPolicy< T
>::Type & 		ConstReferenceType

Public Member Functions

StrongPtr (void)
StrongPtr (ExplicitArg p)
StrongPtr (ImplicitArg p)
StrongPtr (const StrongPtr &rhs)
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>
StrongPtr (const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs)
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>
StrongPtr (StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs)
StrongPtr (RefToValue< StrongPtr > rhs)
operator RefToValue (void)
StrongPtr & | operator= (const StrongPtr &rhs)
StrongPtr & | operator= (T *p)
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>
StrongPtr & | operator= (const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs)
bool | IsStrong (void) const
void | Swap (StrongPtr &rhs)
~StrongPtr ()
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)
PointerType operator-> ()
ConstPointerType | operator-> () const
ReferenceType operator * ()
ConstReferenceType | operator * () const
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.
bool | operator! () const
operator unspecified_boolean_type () const
operator AutomaticConversionResult () const

Protected Member Functions

PointerType | GetPointer (void)
ConstPointerType | GetPointer (void) const

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

Definition at line 845 of file StrongPtr.h.

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

Definition at line 1098 of file StrongPtr.h.

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.

Definition at line 1110 of file StrongPtr.h.

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.

Definition at line 1118 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclass< T, U > Struct Template Reference

Loki::SuperSubclass

Loki::SuperSubclass< T, U > Struct Template Reference

List of all members.

Public Types

enum
enum

Detailed Description

template<class T, class U>
struct Loki::SuperSubclass< T, U >

Definition at line 172 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclass< T, void > Struct Template Reference

Loki::SuperSubclass< T, void >

Loki::SuperSubclass< T, void > Struct Template Reference

List of all members.

Public Types

enum
enum

Detailed Description

template<class T>
struct Loki::SuperSubclass< T, void >

Definition at line 198 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclass< void, U > Struct Template Reference

Loki::SuperSubclass< void, U >

Loki::SuperSubclass< void, U > Struct Template Reference

List of all members.

Public Types

enum
enum

Detailed Description

template<class U>
struct Loki::SuperSubclass< void, U >

Definition at line 188 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclass< void, void > Struct Template Reference

Loki::SuperSubclass< void, void >

Loki::SuperSubclass< void, void > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<>
struct Loki::SuperSubclass< void, void >

Definition at line 182 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclassStrict< T, U > Struct Template Reference

Loki::SuperSubclassStrict

Loki::SuperSubclassStrict< T, U > Struct Template Reference

List of all members.

Public Types

enum
enum

Detailed Description

template<class T, class U>
struct Loki::SuperSubclassStrict< T, U >

Definition at line 216 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclassStrict< T, void > Struct Template Reference

Loki::SuperSubclassStrict< T, void >

Loki::SuperSubclassStrict< T, void > Struct Template Reference

List of all members.

Public Types

enum
enum

Detailed Description

template<class T>
struct Loki::SuperSubclassStrict< T, void >

Definition at line 244 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclassStrict< void, U > Struct Template Reference

Loki::SuperSubclassStrict< void, U >

Loki::SuperSubclassStrict< void, U > Struct Template Reference

List of all members.

Public Types

enum
enum

Detailed Description

template<class U>
struct Loki::SuperSubclassStrict< void, U >

Definition at line 233 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::SuperSubclassStrict< void, void > Struct Template Reference

Loki::SuperSubclassStrict< void, void >

Loki::SuperSubclassStrict< void, void > Struct Template Reference

List of all members.

Public Types

enum

Detailed Description

template<>
struct Loki::SuperSubclassStrict< void, void >

Definition at line 227 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Tuple< TList > Struct Template Reference

Loki::Tuple

Loki::Tuple< TList > Struct Template Reference

Inheritance diagram for Loki::Tuple< TList >:

[legend]
Collaboration diagram for Loki::Tuple< TList >:

[legend]

Detailed Description

template<class TList>
struct Loki::Tuple< TList >

Definition at line 142 of file HierarchyGenerators.h.

The documentation for this struct was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TupleUnit< T > Struct Template Reference

Loki::TupleUnit

Loki::TupleUnit< T > Struct Template Reference

List of all members.

Public Member Functions

operator T & ()
operator const T & () const

Public Attributes

T value_

Detailed Description

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

Definition at line 128 of file HierarchyGenerators.h.

The documentation for this struct was generated from the following file:
  • HierarchyGenerators.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::TwoRefCountInfo Class Reference

Loki::Private::TwoRefCountInfo

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

#include <StrongPtr.h>

List of all members.

Public Member Functions

TwoRefCountInfo (bool strong)
TwoRefCountInfo (void *p, bool strong)
~TwoRefCountInfo (void)
bool | HasStrongPointer (void) const
bool | HasWeakPointer (void) const
void | IncStrongCount (void)
void | IncWeakCount (void)
void | DecStrongCount (void)
void | DecWeakCount (void)
void | ZapPointer (void)
void | SetPointer (void *p)
void * | GetPointer (void) const
void *& | GetPointerRef (void) const

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.

Definition at line 318 of file StrongPtr.h.

The documentation for this class was generated from the following file:
  • StrongPtr.h
Generated on Sat Jul 7 15:12:39 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TwoRefCounts Class Reference

Loki::TwoRefCounts

Loki::TwoRefCounts Class Reference
[StrongPtr Ownership policies]

#include <StrongPtr.h>

Collaboration diagram for Loki::TwoRefCounts:

[legend]
List of all members.

Protected Member Functions

TwoRefCounts (bool strong)
TwoRefCounts (const void *p, bool strong)
TwoRefCounts (const TwoRefCounts &rhs, bool strong)
bool | Release (bool strong)
void | Increment (bool strong)
bool | Decrement (bool strong)
bool | HasStrongPointer (void) const
void | Swap (TwoRefCounts &rhs)
void | SetPointer (void *p)
void | ZapPointer (void)
void *& | GetPointerRef (void) const
void * | GetPointer (void) const

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.

Definition at line 550 of file StrongPtr.h.

The documentation for this class was generated from the following files:
  • StrongPtr.h
  • StrongPtr.cpp
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TwoRefLinks Class Reference

Loki::TwoRefLinks

Loki::TwoRefLinks Class Reference
[StrongPtr Ownership policies]

#include <StrongPtr.h>

Collaboration diagram for Loki::TwoRefLinks:

[legend]
List of all members.

Protected Member Functions

TwoRefLinks (bool strong)
TwoRefLinks (const void *p, bool strong)
TwoRefLinks (const TwoRefLinks &rhs, bool strong)
bool | Release (bool strong)
void | Swap (TwoRefLinks &rhs)
bool | Merge (TwoRefLinks &rhs)
bool | HasStrongPointer (void) const
void | ZapPointer (void)
void | SetPointer (void *p)
void * | GetPointer (void) const
void *& | GetPointerRef (void) const

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.

Definition at line 760 of file StrongPtr.h.

Member Function Documentation

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

Definition at line 455 of file StrongPtr.cpp.

References m_next, and m_prev.

The documentation for this class was generated from the following files:
  • StrongPtr.h
  • StrongPtr.cpp
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Type2Type< T > Struct Template Reference

Loki::Type2Type

Loki::Type2Type< T > Struct Template Reference

List of all members.

Public Types

typedef T OriginalType

Detailed Description

template<typename T>
struct Loki::Type2Type< T >

Definition at line 44 of file TypeManip.h.

The documentation for this struct was generated from the following file:
  • TypeManip.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::TypeAt< Typelist< Head, Tail >, 0 > Struct Template Reference

Loki::TL::TypeAt< Typelist< Head, Tail >, 0 >

Loki::TL::TypeAt< Typelist< Head, Tail >, 0 > Struct Template Reference

List of all members.

Public Types

typedef Head Result

Detailed Description

template<class Head, class Tail>
struct Loki::TL::TypeAt< Typelist< Head, Tail >, 0 >

Definition at line 124 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::TypeAt< Typelist< Head, Tail >, i > Struct Template Reference

Loki::TL::TypeAt< Typelist< Head, Tail >, i >

Loki::TL::TypeAt< Typelist< Head, Tail >, i > Struct Template Reference

List of all members.

Public Types

typedef TypeAt< Tail, i-1
>::Result 		Result

Detailed Description

template<class Head, class Tail, unsigned int i>
struct Loki::TL::TypeAt< Typelist< Head, Tail >, i >

Definition at line 130 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::TypeAtNonStrict< TList, index, DefaultType > Struct Template Reference

Loki::TL::TypeAtNonStrict

Loki::TL::TypeAtNonStrict< TList, index, DefaultType > Struct Template Reference

List of all members.

Public Types

typedef DefaultType Result

Detailed Description

template<class TList, unsigned int index, typename DefaultType = NullType>
struct Loki::TL::TypeAtNonStrict< TList, index, DefaultType >

Definition at line 149 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType > Struct Template Reference

Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType >

Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType > Struct Template Reference

List of all members.

Public Types

typedef Head Result

Detailed Description

template<class Head, class Tail, typename DefaultType>
struct Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType >

Definition at line 155 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType > Struct Template Reference

Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType >

Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType > Struct Template Reference

List of all members.

Public Types

typedef TypeAtNonStrict< Tail,
i-1, DefaultType >::Result 		Result

Detailed Description

template<class Head, class Tail, unsigned int i, typename DefaultType>
struct Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType >

Definition at line 161 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:46 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TypeInfo Class Reference

Loki::TypeInfo

Loki::TypeInfo Class Reference

List of all members.

Public Member Functions

TypeInfo ()
TypeInfo (const std::type_info &)
const std::type_info & | Get () const
bool | before (const TypeInfo &rhs) const
const char * | name () const

Detailed Description

Definition at line 32 of file LokiTypeInfo.h.

The documentation for this class was generated from the following file:
  • LokiTypeInfo.h
Generated on Sat Jul 7 15:12:03 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Typelist< T, U > Struct Template Reference

Loki::Typelist

Loki::Typelist< T, U > Struct Template Reference

List of all members.

Public Types

typedef T | Head
typedef U | Tail

Detailed Description

template<class T, class U>
struct Loki::Typelist< T, U >

Definition at line 38 of file Typelist.h.

The documentation for this struct was generated from the following file:
  • Typelist.h
Generated on Sat Jul 7 15:12:17 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TypeTraits< T > Class Template Reference

Loki::TypeTraits

Loki::TypeTraits< T > Class Template Reference

List of all members.

Public Types

enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
enum
typedef UnConst< T >::Result | NonConstType
typedef UnVolatile< T >::Result | NonVolatileType
typedef UnVolatile< typename
UnConst< T >::Result >::Result 		UnqualifiedType
typedef PointerTraits< UnqualifiedType
>::PointeeType 		PointeeType
typedef ReferenceTraits< T
>::ReferredType 		ReferredType
typedef Select< isStdArith||isPointer||isMemberPointer,
T, typename Private::AddParameterType<
T >::Result >::Result 		ParameterType

Detailed Description

template<typename T>
class Loki::TypeTraits< T >

Definition at line 2071 of file TypeTraits.h.

The documentation for this class was generated from the following file:
  • TypeTraits.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::UnRegisterOnDelete< T > Struct Template Reference

Loki::Private::UnRegisterOnDelete

Loki::Private::UnRegisterOnDelete< T > Struct Template Reference

List of all members.

Public Member Functions

~UnRegisterOnDelete ()

Detailed Description

template<class T>
struct Loki::Private::UnRegisterOnDelete< T >

Definition at line 53 of file Register.h.

The documentation for this struct was generated from the following file:
  • Register.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private::UnRegisterOnDeleteElement< T > Struct Template Reference

Loki::Private::UnRegisterOnDeleteElement

Loki::Private::UnRegisterOnDeleteElement< T > Struct Template Reference

List of all members.

Public Attributes

UnRegisterOnDelete< T > unregisterObj

Detailed Description

template<class T>
struct Loki::Private::UnRegisterOnDeleteElement< T >

Definition at line 65 of file Register.h.

The documentation for this struct was generated from the following file:
  • Register.h
Generated on Sat Jul 7 15:12:38 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::UnRegisterOnDeleteSet< ElementList > Class Template Reference

Loki::UnRegisterOnDeleteSet

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

#include <Register.h>

Inheritance diagram for Loki::UnRegisterOnDeleteSet< ElementList >:

[legend]
Collaboration diagram for Loki::UnRegisterOnDeleteSet< ElementList >:

[legend]

Detailed Description

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

Implements a generic register class which unregisters classes of a typelist

Usage
see test/Register

Definition at line 96 of file Register.h.

The documentation for this class was generated from the following file:
  • Register.h
Generated on Sat Jul 7 15:12:04 2007 for Loki by doxygen 1.5.1-p1


Loki: Visitor Class Reference

Visitor Class Reference
[Visitor]

#include <Visitor.h>

Inheritance diagram for Visitor:

[legend]

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 Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Visitor< T, R, false > Class Template Reference

Loki::Visitor< T, R, false >

Loki::Visitor< T, R, false > Class Template Reference

List of all members.

Public Types

typedef R | ReturnType
typedef T | ParamType

Public Member Functions

virtual | ~Visitor ()

Detailed Description

template<class T, typename R>
class Loki::Visitor< T, R, false >

Definition at line 129 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Visitor< T, R, true > Class Template Reference

Loki::Visitor< T, R, true >

Loki::Visitor< T, R, true > Class Template Reference

List of all members.

Public Types

typedef R | ReturnType
typedef const T | ParamType

Public Member Functions

virtual | ~Visitor ()

Detailed Description

template<class T, typename R>
class Loki::Visitor< T, R, true >

Definition at line 139 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Visitor< Typelist< Head, NullType >, R, false > Class Template Reference

Loki::Visitor< Typelist< Head, NullType >, R, false >

Loki::Visitor< Typelist< Head, NullType >, R, false > Class Template Reference

Inheritance diagram for Loki::Visitor< Typelist< Head, NullType >, R, false >:

[legend]
Collaboration diagram for Loki::Visitor< Typelist< Head, NullType >, R, false >:

[legend]
List of all members.

Public Types

typedef R ReturnType

Detailed Description

template<class Head, typename R>
class Loki::Visitor< Typelist< Head, NullType >, R, false >

Definition at line 174 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:19 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Visitor< Typelist< Head, NullType >, R, true > Class Template Reference

Loki::Visitor< Typelist< Head, NullType >, R, true >

Loki::Visitor< Typelist< Head, NullType >, R, true > Class Template Reference

Inheritance diagram for Loki::Visitor< Typelist< Head, NullType >, R, true >:

[legend]
Collaboration diagram for Loki::Visitor< Typelist< Head, NullType >, R, true >:

[legend]
List of all members.

Public Types

typedef R ReturnType

Detailed Description

template<class Head, typename R>
class Loki::Visitor< Typelist< Head, NullType >, R, true >

Definition at line 192 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:19 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Visitor< Typelist< Head, Tail >, R, false > Class Template Reference

Loki::Visitor< Typelist< Head, Tail >, R, false >

Loki::Visitor< Typelist< Head, Tail >, R, false > Class Template Reference

Inheritance diagram for Loki::Visitor< Typelist< Head, Tail >, R, false >:

[legend]
Collaboration diagram for Loki::Visitor< Typelist< Head, Tail >, R, false >:

[legend]
List of all members.

Public Types

typedef R ReturnType

Detailed Description

template<class Head, class Tail, typename R>
class Loki::Visitor< Typelist< Head, Tail >, R, false >

Definition at line 164 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:18 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Visitor< Typelist< Head, Tail >, R, true > Class Template Reference

Loki::Visitor< Typelist< Head, Tail >, R, true >

Loki::Visitor< Typelist< Head, Tail >, R, true > Class Template Reference

Inheritance diagram for Loki::Visitor< Typelist< Head, Tail >, R, true >:

[legend]
Collaboration diagram for Loki::Visitor< Typelist< Head, Tail >, R, true >:

[legend]
List of all members.

Public Types

typedef R ReturnType

Detailed Description

template<class Head, class Tail, typename R>
class Loki::Visitor< Typelist< Head, Tail >, R, true >

Definition at line 182 of file Visitor.h.

The documentation for this class was generated from the following file:
  • Visitor.h
Generated on Sat Jul 7 15:12:19 2007 for Loki by doxygen 1.5.1-p1


Loki: Hierarchical Index

Loki Class Hierarchy

Go to the graphical class hierarchy

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

  • AbstractFactory
  • Loki::AbstractFactoryUnit< T >
  • Loki::Private::Adapter< T >
  • Loki::Private::AddParameterType< U >
  • Loki::Private::AddParameterType< U & >
  • Loki::Private::AddParameterType< void >
  • Loki::Private::AddPointer< U >
  • Loki::Private::AddPointer< U & >
  • Loki::Private::AddReference< U >
  • Loki::Private::AddReference< U & >
  • Loki::Private::AddReference< void >
  • Loki::AllowConversion
  • Loki::AllowReset< P >
  • Loki::AlwaysCreate
  • Loki::AmountLimitedCreation
  • Loki::TL::Append< NullType, NullType >
  • Loki::TL::Append< NullType, T >
  • Loki::TL::Append< NullType, Typelist< Head, Tail > >
  • Loki::TL::Append< Typelist< Head, Tail >, T >
  • Loki::ArrayStorage< T >
  • Loki::AssertCheck< P >
  • Loki::AssertCheckStrict< P >
  • Loki::AssocVector< K, V, C, A >::value_compare
  • Loki::Private::AssocVectorCompare< Value, C >
  • Loki::Private::AssocVectorCompare< V, C >
    • Loki::AssocVector< K, V, C, A >
  • Loki::BaseVisitable< R, CatchAll, false >
  • Loki::BaseVisitable< R, CatchAll, true >
  • Loki::BaseVisitor
  • Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType >
  • Loki::BinderFirst< OriginalFunctor >
  • Loki::Private::BinderFirstBoundTypeStorage< T >
  • Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > >
  • Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
  • Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • Loki::CacheException
  • Loki::CantResetWithStrong< P >
  • Loki::Chainer< Fun1, Fun2 >
  • Loki::Chunk
  • Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >
  • Loki::CompileTimeError< true >
  • Loki::COMRefCounted< P >
  • Loki::ConcreteFactory< AbstractFact, Creator, TList >
  • Loki::ConstPropPtr< T >
  • Loki::Conversion< T, U >
  • Loki::Conversion< T, T >
  • Loki::Conversion< T, void >
  • Loki::Conversion< void, T >
  • Loki::Conversion< void, void >
  • Loki::Private::ConversionHelper< T, U >
  • Loki::Private::ConversionHelper< T, U >::Big
  • Loki::CreateStatic< T >
  • Loki::CreateStatic< T >::MaxAlign
  • Loki::CreateUsing< Alloc >
  • Loki::CreateUsing< Alloc >::Allocator< T >
  • Loki::CreateUsingMalloc< T >
  • Loki::CreateUsingNew< T >
  • Loki::DeepCopy< P >
  • Loki::DefaultCatchAll< R, Visited >
  • Loki::DefaultFactoryError< IdentifierType, AbstractProduct >
  • Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception
  • Loki::DefaultLifetime< T >
  • Loki::DefaultSPStorage< T >
  • Loki::DeletableSingleton< T >
  • Loki::DeleteArray< P >
  • Loki::DeleteNothing< P >
  • Loki::Private::Deleter< T >
  • Loki::DeleteSingle< P >
  • Loki::DeleteUsingFree< P >
  • Loki::TL::DerivedToFront< NullType >
  • Loki::TL::DerivedToFront< Typelist< Head, Tail > >
  • Loki::DestructiveCopy< P >
  • Loki::DisallowConversion
  • Loki::DontPropagateConst< T >
  • Loki::DynamicCaster< To, From >
  • Loki::EmptyType
  • Loki::TL::Erase< NullType, T >
  • Loki::TL::Erase< Typelist< Head, Tail >, T >
  • Loki::TL::Erase< Typelist< T, Tail >, T >
  • Loki::TL::EraseAll< NullType, T >
  • Loki::TL::EraseAll< Typelist< Head, Tail >, T >
  • Loki::TL::EraseAll< Typelist< T, Tail >, T >
  • Loki::EvictionException
  • Loki::EvictionHelper< ST, DT >
    • Loki::EvictAging< DT, ST >
    • Loki::EvictLRU< DT, ST >
  • Loki::EvictRandom< DT, ST >
  • Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • Loki::FactoryImplBase
    • Loki::FactoryImpl< AP, Id, NullType >
    • Loki::FactoryImpl< AP, Id, Seq< P1 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >
    • Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > >
    • Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >>
    • Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >>
    • Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >>
    • Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >>
    • Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >>
    • Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >>
    • Loki::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 > > > > > > >>
    • Loki::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 > > > > > > > >>
    • Loki::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 > > > > > > > > >>
    • Loki::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 > > > > > > > > > >>
    • Loki::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 > > > > > > > > > > >>
    • Loki::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 > > > > > > > > > > > >>
    • Loki::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 > > > > > > > > > > > > >>
    • Loki::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 > > > > > > > > > > > > > >>
    • Loki::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 > > > > > > > > > > > > > > >>
  • Loki::FieldHelper< H, i >
  • Loki::FieldHelper< H, 0 >
  • Loki::FixedAllocator
  • Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback >
  • Loki::FollowIntoDeath
  • Loki::FollowIntoDeath::AfterMaster< Master >
  • Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F >
  • Loki::FollowIntoDeath::With< Lifetime >
  • Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master >
  • Function
  • Loki::FunctionStorage< T >
  • Loki::Functor< R, TList, ThreadingModel >
    • Loki::Function< R(P01)>
    • Loki::Function< R(P01, P02)>
    • Loki::Function< R(P01, P02, P03)>
    • Loki::Function< R(P01, P02, P03, P04)>
    • Loki::Function< R(P01, P02, P03, P04, P05)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>
    • Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
    • Loki::Function<>
  • Loki::Functor< >
  • Loki::Functor< R >
    • Loki::Function< R()>
  • Loki::Functor< R, Loki::Seq< P01 > >
  • Loki::Functor< R, Loki::Seq< P01, P02 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14 > >
  • Loki::Functor< R, Loki::Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15 > >
  • Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs >
  • Loki::FunctorHandler< ParentFunctor, Fun >
  • Loki::GenLinearHierarchy< NullType, Unit, Root >
  • Loki::GenLinearHierarchy< Typelist< T, NullType >, Unit, Root >
  • Loki::GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root >
  • Loki::GenScatterHierarchy< AtomicType, Unit >
    • Loki::RegisterOnCreateSet< ElementList >
    • Loki::Tuple< TList >
    • Loki::UnRegisterOnDeleteSet< ElementList >
  • Loki::GenScatterHierarchy< ElementList, Loki::Private::RegisterOnCreateElement< T > >
  • Loki::GenScatterHierarchy< ElementList, Loki::Private::UnRegisterOnDeleteElement< T > >
  • Loki::GenScatterHierarchy< NullType, Unit >
  • Loki::GenScatterHierarchy< T1, Unit >
    • Loki::GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit >
      • Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >
  • Loki::GenScatterHierarchy< T2, Unit >
    • Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >
  • Loki::GenScatterHierarchy< TList, Loki::TupleUnit< T > >
  • Loki::GenScatterHierarchy< TList, Unit >
    • Loki::AbstractFactory< TList, Unit >
  • Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T >
  • Loki::HeapStorage< T >
  • ImplOf
  • Loki::TL::IndexOf< NullType, T >
  • Loki::TL::IndexOf< Typelist< Head, Tail >, T >
  • Loki::TL::IndexOf< Typelist< T, Tail >, T >
  • Loki::Int2Type< v >
  • Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType >
  • Loki::IsCustomFloat< T >
  • Loki::IsCustomSignedInt< T >
  • Loki::IsCustomUnsignedInt< T >
  • Loki::Private::IsFunctionPointerRaw< T >
  • Loki::Private::IsFunctionPointerRaw< T(*)()>
  • Loki::Private::IsFunctionPointerRaw< T(*)(...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02, P03,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01, P02,...)>
  • Loki::Private::IsFunctionPointerRaw< T(*)(P01,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)() volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)()>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)>
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile >
  • Loki::Private::IsMemberFunctionPointerRaw< T(S::*)(P01,...)>
  • Loki::IsSameType< T, U >
  • Loki::IsSameType< T, T >
  • Loki::TL::IterateTypes< AtomicType, GenFunc >
  • Loki::TL::IterateTypes< NullType, GenFunc >
  • Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
  • Loki::Key< Factory, IdentifierType >
  • Loki::TL::Length< NullType >
  • Loki::TL::Length< Typelist< T, U > >
  • std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > >
  • std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
  • Loki::Private::LifetimeTracker
    • Loki::Private::ConcreteLifetimeTracker< T, Destroyer >
  • LockableTwoRefCountInfo
  • LockableTwoRefCounts
  • Loki::LockedStorage< T >
  • Loki::Locker< T >
  • Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >
  • Loki::TL::MakeTypelist<>
  • Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
  • Loki::TL::MostDerived< NullType, T >
  • Loki::TL::MostDerived< Typelist< Head, Tail >, T >
  • Loki::Mutex
  • Loki::TL::nameof_type< T >
  • Loki::NeverCreate
  • Loki::NeverCreate::Exception
  • Loki::NeverReset< P >
  • Loki::NoCheck< P >
  • Loki::NoCopy< P >
  • Loki::NoDestroy< T >
  • Loki::TL::NoDuplicates< NullType >
  • Loki::TL::NoDuplicates< Typelist< Head, Tail > >
  • Loki::NoStatisticPolicy
  • Loki::NullPointerException
  • Loki::NullType
  • Loki::OpNewFactoryUnit< ConcreteProduct, Base >
  • Loki::Private::OrderedStaticCreatorFunc
    • Loki::Private::OrderedStaticBase< T >
      • Loki::OrderedStatic< L, T, Loki::NullType >
      • Loki::OrderedStatic< L, T, Loki::Seq< P1 > >
      • Loki::OrderedStatic< L, T, P1(*)() >
  • Loki::Private::OrderedStaticManagerClass
  • Loki::PhoenixSingleton< T >
  • Loki::Pimpl< T, Pointer >
  • Loki::PimplOf< T, Ptr >
  • PImplOf
  • Loki::PimplOwner< T, Pointer >
  • Loki::PrintfState< Device, Char >
  • Loki::PropagateConst< T >
  • Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
  • Loki::RateLimitedCreation
  • Loki::RateLimitedCreation::Exception
  • Loki::RefCounted< P >
  • RefCountedMT
  • Loki::RefCountedMTAdj< ThreadingModel, MX >
  • Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
  • Loki::Private::RefLinkedBase
    • Loki::RefLinked< P >
  • Loki::RefToValue< T >
  • Loki::Private::RegisterOnCreate< T >
  • Loki::Private::RegisterOnCreateElement< T >
  • Loki::RejectNull< P >
  • Loki::RejectNullStatic< P >
  • Loki::RejectNullStrict< P >
  • Loki::TL::Replace< NullType, T, U >
  • Loki::TL::Replace< Typelist< Head, Tail >, T, U >
  • Loki::TL::Replace< Typelist< T, Tail >, T, U >
  • Loki::TL::ReplaceAll< NullType, T, U >
  • Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U >
  • Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U >
  • Loki::TL::Reverse< NullType >
  • Loki::TL::Reverse< Typelist< Head, Tail > >
  • Loki::RimplOf< T, UsedPimpl >
  • Loki::RimplOf< T, UsedPimpl >::Owner
  • Loki::ScopeGuardImplBase
    • Loki::ObjScopeGuardImpl0< Obj, MemFun >
    • Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
    • Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
    • Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
    • 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::Select< flag, T, U >
  • Loki::Select< false, T, U >
  • Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 >
  • Loki::Seq<>
  • Loki::SimplePointer< AbstractProduct >
  • Loki::SimpleStatisticPolicy
  • Loki::SingleThreaded< Host, MutexPolicy >
  • Loki::SingleThreaded< Host, MutexPolicy >::Lock
  • Loki::Singleton< T >
  • Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
    • Loki::LongevityLifetime::DieDirectlyBeforeLast< T >
      • Loki::LongevityLifetime::DieAsSmallObjectChild< T >
    • Loki::LongevityLifetime::DieLast< T >
      • Loki::LongevityLifetime::DieAsSmallObjectParent< T >
  • Loki::LongevityLifetime::SingletonFixedLongevity< 0, T >
    • Loki::LongevityLifetime::DieFirst< T >
  • Loki::LongevityLifetime::SingletonFixedLongevity< 0xFFFFFFFF, T >
  • Loki::LongevityLifetime::SingletonFixedLongevity< 0xFFFFFFFF-1, T >
  • Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >
  • Loki::SingletonWithLongevity< T >
  • Loki::TL::sizeof_type< T >
  • Loki::SmallObjAllocator
    • Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
    • Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
    • Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
    • Loki::SmallValueObject< ThreadingModel >
      • Loki::Private::FunctorImplBase< R, ThreadingModel >
        • Loki::FunctorImpl< R, NullType, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel >
        • Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >
        • Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel >
        • Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel >
        • Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel >
        • Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel >
        • Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel >
        • Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel >
        • Loki::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 >
        • Loki::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 >
        • Loki::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 >
        • Loki::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 >
        • Loki::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 >
        • Loki::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 >
        • Loki::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 >
        • Loki::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 >
        • Loki::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 >
  • Loki::SmallObjectBase< ThreadingModel, 4096, 256, 4,::Loki::LongevityLifetime::DieAsSmallObjectParent< T >,::Loki::Mutex >
  • Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • Loki::StaticCaster< To, From >
  • Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType >
  • Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • Loki::SuperSubclass< T, U >
  • Loki::SuperSubclass< T, void >
  • Loki::SuperSubclass< void, U >
  • Loki::SuperSubclass< void, void >
  • Loki::SuperSubclassStrict< T, U >
  • Loki::SuperSubclassStrict< T, void >
  • Loki::SuperSubclassStrict< void, U >
  • Loki::SuperSubclassStrict< void, void >
  • Loki::TupleUnit< T >
  • Loki::Private::TwoRefCountInfo
  • Loki::TwoRefCounts
  • Loki::TwoRefLinks
  • Loki::Type2Type< T >
  • Loki::TL::TypeAt< Typelist< Head, Tail >, 0 >
  • Loki::TL::TypeAt< Typelist< Head, Tail >, i >
  • Loki::TL::TypeAtNonStrict< TList, index, DefaultType >
  • Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType >
  • Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType >
  • Loki::TypeInfo
  • Loki::Typelist< T, U >
  • Loki::TypeTraits< T >
  • Loki::Private::UnRegisterOnDelete< T >
  • Loki::Private::UnRegisterOnDeleteElement< T >
  • Visitor
  • Visitor< Head, R >
    • Loki::BaseVisitorImpl< Typelist< Head, NullType >, R >
    • Loki::BaseVisitorImpl< Typelist< Head, Tail >, R >
  • Visitor< Head, R, false >
    • Loki::Visitor< Typelist< Head, NullType >, R, false >
    • Loki::Visitor< Typelist< Head, Tail >, R, false >
  • Visitor< Head, R, true >
    • Loki::Visitor< Typelist< Head, NullType >, R, true >
    • Loki::Visitor< Typelist< Head, Tail >, R, true >
  • Loki::Visitor< T, R, false >
  • Loki::Visitor< T, R, true >
  • Visitor< Tail, R, false >
    • Loki::Visitor< Typelist< Head, Tail >, R, false >
  • Visitor< Tail, R, true >
    • Loki::Visitor< Typelist< Head, Tail >, R, true >
  • Visitor< TList, R >
    • Loki::CyclicVisitor< R, TList >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- a -

  • AbstractProduct : Loki::OpNewFactoryUnit< ConcreteProduct, Base > , Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
  • AcceptImpl()
: Loki::BaseVisitable< R, CatchAll, false >
, Loki::BaseVisitable< R, CatchAll, true >
  • Add() : Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > , Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • Allocate()
: Loki::SmallObjAllocator
, Loki::FixedAllocator
  • allocator : Loki::CreateUsing< Alloc >::Allocator< T >
  • allocator_type : Loki::AssocVector< K, V, C, A >
  • AllocatorSingleton() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • AmountLimitedCreation() : Loki::AmountLimitedCreation
  • ArrayStorage() : Loki::ArrayStorage< T >
  • AssertCheck() : Loki::AssertCheck< P >
  • AssertCheckStrict() : Loki::AssertCheckStrict< P >
  • AssocVector : Loki::AssocVector< K, V, C, A >::value_compare , Loki::AssocVector< K, V, C, A >
  • AssocVectorCompare() : Loki::Private::AssocVectorCompare< Value, C >
  • atexitCallback() : Loki::DeletableSingleton< T >
  • AtomicAdd() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicAssign() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicDecrement() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicDivide() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicIncrement() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicMultiply() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicSubtract() : Loki::SingleThreaded< Host, MutexPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- k -

  • Key() : Loki::Key< Factory, IdentifierType >
  • key_comp() : Loki::AssocVector< K, V, C, A >
  • key_compare : Loki::AssocVector< K, V, C, A >
  • key_type : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- l -

  • LeftBase : Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > , Loki::FieldHelper< H, 0 >
  • LessThan() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • LifetimeTracker() : Loki::Private::LifetimeTracker
  • Lock()
: Loki::SingleThreaded< Host, MutexPolicy >::Lock
, Loki::Mutex
, Loki::SingleThreaded< Host, MutexPolicy >::Lock
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • LockedStorage() : Loki::LockedStorage< T >
  • Locker() : Loki::Locker< T >
  • LockingPtr() : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • longDouble_ : Loki::CreateStatic< T >::MaxAlign
  • longInt_ : Loki::CreateStatic< T >::MaxAlign
  • lower_bound() : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- m -

  • m_mHitCount : Loki::EvictionHelper< ST, DT >
  • MakeGuard() : Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ScopeGuardImpl0< F > , Loki::ScopeGuardImpl1< F, P1 > , Loki::ScopeGuardImpl2< F, P1, P2 > , Loki::ScopeGuardImpl3< F, P1, P2, P3 >
  • MakeObjGuard()
: Loki::ObjScopeGuardImpl0< Obj, MemFun >
, Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
, Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
, Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • mapped_type : Loki::AssocVector< K, V, C, A >
  • max_size() : Loki::AssocVector< K, V, C, A >
  • memFun_ : Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ObjScopeGuardImpl0< Obj, MemFun > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
  • MemFunHandler() : Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
  • Merge() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::RefLinked< P > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • Mutex() : Loki::Mutex
  • MyAllocator : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • MyAllocatorSingleton : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • MyThreadingModel : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- n -

  • name()
: Loki::SimplePointer< AbstractProduct >
, Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
, Loki::NeverCreate
, Loki::AmountLimitedCreation
, Loki::EvictLRU< DT, ST >
, Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::SimpleStatisticPolicy
, Loki::AlwaysCreate
, Loki::NoStatisticPolicy
, Loki::RateLimitedCreation
  • needCallback : Loki::DeletableSingleton< T >
  • NoCheck() : Loki::NoCheck< P >
  • NoCopy() : Loki::NoCopy< P >
  • NonConstType : Loki::TypeTraits< T >
  • NonVolatileType : Loki::TypeTraits< T >
  • NullPointerException() : Loki::NullPointerException
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- o -

  • obj_ : Loki::ObjScopeGuardImpl0< Obj, MemFun > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
  • ObjAllocatorSingleton : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ObjectType : Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >
  • ObjScopeGuardImpl0() : Loki::ObjScopeGuardImpl0< Obj, MemFun >
  • ObjScopeGuardImpl1() : Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
  • ObjScopeGuardImpl2() : Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
  • ObjScopeGuardImpl3() : Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • onCreate()
: Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::NeverCreate
, Loki::NoStatisticPolicy
, Loki::AlwaysCreate
, Loki::RateLimitedCreation
, Loki::SimpleStatisticPolicy
, Loki::AmountLimitedCreation
, Loki::EvictLRU< DT, ST >
  • OnDeadReference()
: Loki::DefaultLifetime< T >
, Loki::PhoenixSingleton< T >
, Loki::DeletableSingleton< T >
, Loki::SingletonWithLongevity< T >
, Loki::NoDestroy< T >
, Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
, Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master >
, Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F >
  • onDebug()
: Loki::NoStatisticPolicy
, Loki::SimpleStatisticPolicy
  • OnDefault()
: Loki::NoCheck< P >
, Loki::AssertCheck< P >
, Loki::AssertCheckStrict< P >
, Loki::RejectNullStatic< P >
, Loki::RejectNull< P >
  • OnDereference()
: Loki::NoCheck< P >
, Loki::AssertCheck< P >
, Loki::AssertCheckStrict< P >
, Loki::RejectNullStatic< P >
, Loki::RejectNull< P >
, Loki::RejectNullStrict< P >
  • onDestroy()
: Loki::EvictLRU< DT, ST >
, Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::NoStatisticPolicy
, Loki::NeverCreate
, Loki::AlwaysCreate
, Loki::SimpleStatisticPolicy
, Loki::RateLimitedCreation
, Loki::AmountLimitedCreation
  • onFetch()
: Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::NoStatisticPolicy
, Loki::SimpleStatisticPolicy
, Loki::EvictLRU< DT, ST >
  • OnInit()
: Loki::NoCheck< P >
, Loki::AssertCheck< P >
, Loki::AssertCheckStrict< P >
, Loki::RejectNullStatic< P >
, Loki::RejectNull< P >
, Loki::RejectNullStrict< P >
  • onRelease()
: Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::NoStatisticPolicy
, Loki::SimpleStatisticPolicy
, Loki::EvictLRU< DT, ST >
  • OnReleaseAll()
: Loki::CantResetWithStrong< P >
, Loki::AllowReset< P >
, Loki::NeverReset< P >
  • OnResetAll()
: Loki::AllowReset< P >
, Loki::CantResetWithStrong< P >
, Loki::NeverReset< P >
  • OnUnknownType() : Loki::DefaultFactoryError< IdentifierType, AbstractProduct >
  • OnUnknownVisitor() : Loki::DefaultCatchAll< R, Visited >
  • OP : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator *()
: Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
, Loki::Private::OrderedStaticBase< T >
, Loki::ConstPropPtr< T >
, Loki::Pimpl< T, Pointer >
, Loki::HeapStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::ArrayStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::FunctionStorage< T >
  • operator AutomaticConversionResult() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator const T &() : Loki::TupleUnit< T >
  • operator delete() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • operator int() : Loki::PrintfState< Device, Char >
  • operator new() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • operator RefToValue() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator T &() : Loki::TupleUnit< T > , Loki::RefToValue< T >
  • operator T *() : Loki::Locker< T >
  • operator unspecified_bool_type() : Loki::Functor< R, TList, ThreadingModel >
  • operator unspecified_boolean_type() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator!() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator!=() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator()()
: Loki::PrintfState< Device, Char >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::PrintfState< Device, Char >
, Loki::Chainer< Fun1, Fun2 >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Chainer< Fun1, Fun2 >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::AssocVector< K, V, C, A >::value_compare
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs >
, Loki::BinderFirst< OriginalFunctor >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Chainer< Fun1, Fun2 >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
, std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::PrintfState< Device, Char >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::BinderFirst< OriginalFunctor >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::PrintfState< Device, Char >
, Loki::BinderFirst< OriginalFunctor >
, Loki::PrintfState< Device, Char >
, Loki::BinderFirst< OriginalFunctor >
, Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::BinderFirst< OriginalFunctor >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::PrintfState< Device, Char >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::BinderFirst< OriginalFunctor >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Chainer< Fun1, Fun2 >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::Chainer< Fun1, Fun2 >
, Loki::PrintfState< Device, Char >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::PrintfState< Device, Char >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::PrintfState< Device, Char >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::TL::IterateTypes< NullType, GenFunc >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::PrintfState< Device, Char >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::TL::nameof_type< T >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::TL::sizeof_type< T >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::BinderFirst< OriginalFunctor >
, Loki::TL::IterateTypes< AtomicType, GenFunc >
, Loki::Private::Adapter< T >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Chainer< Fun1, Fun2 >
, Loki::PrintfState< Device, Char >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::PrintfState< Device, Char >
  • operator->()
: Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::Pimpl< T, Pointer >
, Loki::ConstPropPtr< T >
, Loki::HeapStorage< T >
, Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
, Loki::Private::OrderedStaticBase< T >
, Loki::ConstPropPtr< T >
, Loki::LockedStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::DefaultSPStorage< T >
, Loki::FunctionStorage< T >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::Locker< T >
, Loki::ArrayStorage< T >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator<() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::AssocVector< K, V, C, A > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator<=() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator=() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::AssocVector< K, V, C, A > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::Functor< R, TList, ThreadingModel > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > , Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • operator==() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator>() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator>=() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator[]() : Loki::AssocVector< K, V, C, A >
  • OrderedStatic() : Loki::OrderedStatic< L, T, P1(*)() > , Loki::OrderedStatic< L, T, Loki::Seq< P1 > > , Loki::OrderedStatic< L, T, Loki::NullType >
  • OrderedStaticBase() : Loki::Private::OrderedStaticBase< T >
  • OriginalFunctor : Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > > , Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
  • OriginalParm1 : Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
  • OriginalType : Loki::Type2Type< T >
  • Owner()
: Loki::RimplOf< T, UsedPimpl >::Owner
, Loki::PimplOf< T, Ptr >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- z -

  • ZapPointer()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefLinks
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- ~ -

  • ~AbstractFactoryUnit() : Loki::AbstractFactoryUnit< T >
  • ~AllocatorSingleton() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~BaseVisitable()
: Loki::BaseVisitable< R, CatchAll, false >
, Loki::BaseVisitable< R, CatchAll, true >
  • ~BaseVisitor() : Loki::BaseVisitor
  • ~CachedFactory() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • ~ConcreteLifetimeTracker() : Loki::Private::ConcreteLifetimeTracker< T, Destroyer >
  • ~ConstPropPtr() : Loki::ConstPropPtr< T >
  • ~EvictAging() : Loki::EvictAging< DT, ST >
  • ~EvictLRU() : Loki::EvictLRU< DT, ST >
  • ~EvictRandom() : Loki::EvictRandom< DT, ST >
  • ~Factory() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • ~FactoryImpl() : Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::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 > > > > > > > > > > >> , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> , Loki::FactoryImpl< AP, Id, NullType > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > > >> , Loki::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 > > > > > > > > > >>
  • ~FixedAllocator() : Loki::FixedAllocator
  • ~FunctorImplBase() : Loki::Private::FunctorImplBase< R, ThreadingModel >
  • ~LockedStorage() : Loki::LockedStorage< T >
  • ~Locker() : Loki::Locker< T >
  • ~LockingPtr() : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • ~Mutex() : Loki::Mutex
  • ~ObjScopeGuardImpl0() : Loki::ObjScopeGuardImpl0< Obj, MemFun >
  • ~ObjScopeGuardImpl1() : Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
  • ~ObjScopeGuardImpl2() : Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
  • ~ObjScopeGuardImpl3() : Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • ~OrderedStaticBase() : Loki::Private::OrderedStaticBase< T >
  • ~Pimpl() : Loki::Pimpl< T, Pointer >
  • ~PrintfState() : Loki::PrintfState< Device, Char >
  • ~ScopeGuardImpl0() : Loki::ScopeGuardImpl0< F >
  • ~ScopeGuardImpl1() : Loki::ScopeGuardImpl1< F, P1 >
  • ~ScopeGuardImpl2() : Loki::ScopeGuardImpl2< F, P1, P2 >
  • ~ScopeGuardImpl3() : Loki::ScopeGuardImpl3< F, P1, P2, P3 >
  • ~ScopeGuardImpl4() : Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
  • ~ScopeGuardImpl5() : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • ~ScopeGuardImplBase() : Loki::ScopeGuardImplBase
  • ~SingletonFixedLongevity() : Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
  • ~SmallObjAllocator() : Loki::SmallObjAllocator
  • ~SmallObject() : Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~SmallObjectBase() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~SmallValueObject() : Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~SmartPointer() : Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • ~SmartPtr() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • ~StrongPtr() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • ~TwoRefCountInfo() : Loki::Private::TwoRefCountInfo
  • ~UnRegisterOnDelete() : Loki::Private::UnRegisterOnDelete< T >
  • ~Visitor()
: Loki::Visitor< T, R, true >
, Loki::Visitor< T, R, false >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- b -

  • begin() : Loki::AssocVector< K, V, C, A >
  • BinderFirst() : Loki::BinderFirst< OriginalFunctor >
  • BlockSize() : Loki::FixedAllocator
  • BoundFunctorType : Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- c -

  • CachedFactory() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • canCreate()
: Loki::NeverCreate
, Loki::AlwaysCreate
, Loki::RateLimitedCreation
, Loki::AmountLimitedCreation
  • Cast()
: Loki::StaticCaster< To, From >
, Loki::DynamicCaster< To, From >
  • Chainer() : Loki::Chainer< Fun1, Fun2 >
  • clear() : Loki::AssocVector< K, V, C, A >
  • ClearExtraMemory() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • Clone()
: Loki::RefCounted< P >
, Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
, Loki::COMRefCounted< P >
, Loki::DeepCopy< P >
, Loki::RefLinked< P >
, Loki::DestructiveCopy< P >
, Loki::NoCopy< P >
, Loki::Private::FunctorImplBase< R, ThreadingModel >
  • Compare() : Loki::Private::LifetimeTracker
  • COMRefCounted() : Loki::COMRefCounted< P >
  • ConcreteLifetimeTracker() : Loki::Private::ConcreteLifetimeTracker< T, Destroyer >
  • ConcreteProductList : Loki::ConcreteFactory< AbstractFact, Creator, TList >
  • const_iterator : Loki::AssocVector< K, V, C, A >
  • const_pointer : Loki::AssocVector< K, V, C, A >
  • const_reference : Loki::AssocVector< K, V, C, A >
  • const_reverse_iterator : Loki::AssocVector< K, V, C, A >
  • ConstLeftBase : Loki::FieldHelper< H, 0 >
  • ConstOrNotType : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • ConstPointerType : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • ConstPropPtr() : Loki::ConstPropPtr< T >
  • ConstReferenceType : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • ConstRightBase : Loki::FieldHelper< H, i >
  • CopyArg : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • count : Loki::Key< Factory, IdentifierType > , Loki::AssocVector< K, V, C, A >
  • CountEmptyChunks() : Loki::FixedAllocator
  • Create()
: Loki::CreateUsing< Alloc >::Allocator< T >
, Loki::CreateUsingMalloc< T >
, Loki::CreateStatic< T >
, Loki::CreateUsingNew< T >
, Loki::AbstractFactory< TList, Unit >
  • createObject() : Loki::OrderedStatic< L, T, Loki::NullType >
  • CreateObject() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • createObject() : Loki::OrderedStatic< L, T, Loki::Seq< P1 > >
  • CreateObject() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • createObject() : Loki::OrderedStatic< L, T, P1(*)() >
  • CreateObject() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • Creator : Loki::Private::OrderedStaticManagerClass
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- d -

  • d : Loki::PimplOwner< T, Pointer > , Loki::RimplOf< T, UsedPimpl >::Owner
  • Deallocate()
: Loki::SmallObjAllocator
, Loki::FixedAllocator
  • DecStrongCount() : Loki::Private::TwoRefCountInfo
  • DecWeakCount() : Loki::Private::TwoRefCountInfo
  • DeepCopy() : Loki::DeepCopy< P >
  • Default()
: Loki::DefaultSPStorage< T >
, Loki::LockedStorage< T >
, Loki::ArrayStorage< T >
, Loki::FunctionStorage< T >
, Loki::DeleteUsingFree< P >
, Loki::DeleteNothing< P >
, Loki::DeleteSingle< P >
, Loki::DeleteArray< P >
, Loki::HeapStorage< T >
  • DefaultSPStorage() : Loki::DefaultSPStorage< T >
  • Delete()
: Loki::Private::Deleter< T >
, Loki::DeleteUsingFree< P >
, Loki::DeleteNothing< P >
, Loki::DeleteSingle< P >
, Loki::DeleteArray< P >
  • deleter : Loki::DeletableSingleton< T >
  • Destroy()
: Loki::CreateUsingMalloc< T >
, Loki::DefaultSPStorage< T >
, Loki::LockedStorage< T >
, Loki::ArrayStorage< T >
, Loki::CreateStatic< T >
, Loki::CreateUsingNew< T >
, Loki::CreateUsing< Alloc >::Allocator< T >
, Loki::FunctionStorage< T >
, Loki::HeapStorage< T >
  • DestructiveCopy() : Loki::DestructiveCopy< P >
  • difference_type : Loki::AssocVector< K, V, C, A >
  • DisallowConversion() : Loki::DisallowConversion
  • Dismiss() : Loki::ScopeGuardImplBase
  • dismissed_ : Loki::ScopeGuardImplBase
  • displayCacheType() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • Do()
: Loki::FieldHelper< H, i >
, Loki::FieldHelper< H, 0 >
  • DoClone()
: Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Chainer< Fun1, Fun2 >
, Loki::BinderFirst< OriginalFunctor >
, Loki::FunctorHandler< ParentFunctor, Fun >
  • DoCreate()
: Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
, Loki::OpNewFactoryUnit< ConcreteProduct, Base >
  • DoDispatch() : Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType >
  • double_ : Loki::CreateStatic< T >::MaxAlign
  • dummy : Loki::Private::ConversionHelper< T, U >::Big
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- e -

  • ElementType : Loki::FieldHelper< H, 0 > , Loki::FieldHelper< H, i >
  • empty() : Loki::AssocVector< K, V, C, A >
  • encapsulate() : Loki::SimplePointer< AbstractProduct > , Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • end() : Loki::AssocVector< K, V, C, A >
  • equal_range() : Loki::AssocVector< K, V, C, A >
  • Equals() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • erase() : Loki::AssocVector< K, V, C, A >
  • evict()
: Loki::EvictRandom< DT, ST >
, Loki::EvictLRU< DT, ST >
, Loki::EvictAging< DT, ST >
  • EvictAging() : Loki::EvictAging< DT, ST >
  • Execute() : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ScopeGuardImpl2< F, P1, P2 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > , Loki::ScopeGuardImpl3< F, P1, P2, P3 > , Loki::ScopeGuardImpl0< F > , Loki::ScopeGuardImpl1< F, P1 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ObjScopeGuardImpl0< Obj, MemFun >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- f -

  • Factory() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • FBase : Loki::Function<> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R()> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> , Loki::Function< R(P01, P02, P03, P04, P05)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
  • find() : Loki::AssocVector< K, V, C, A >
  • FixedAllocator()
: Loki::FixedAllocator
, Loki::Chunk
  • float_ : Loki::CreateStatic< T >::MaxAlign
  • fun_ : 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 >
  • Func : Loki::OrderedStatic< L, T, P1(*)() >
  • Function() : Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01, P02, P03, P04, P05)> , Loki::Function< R()> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function< R()> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R()> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R(P01, P02, P03, P04, P05)> , Loki::Function< R()> , Loki::Function< R(P01, P02, P03, P04, P05)> , Loki::Function< R()> , Loki::Function< R(P01, P02, P03, P04, P05)> , Loki::Function< R()> , Loki::Function<> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function<> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function<> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function<> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function<> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function<> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
  • FunctionStorage() : Loki::FunctionStorage< T >
  • Functor() : Loki::Functor< R, TList, ThreadingModel >
  • FunctorDispatcherHelper() : Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs >
  • FunctorHandler() : Loki::FunctorHandler< ParentFunctor, Fun >
  • FunctorImplBase() : Loki::Private::FunctorImplBase< R, ThreadingModel >
  • FunctorImplBaseType : Loki::Private::FunctorImplBase< R, ThreadingModel >
  • FunctorType : Loki::FunctionStorage< T >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- g -

  • GenericVisit() : Loki::CyclicVisitor< R, TList >
  • GetAlignment() : Loki::SmallObjAllocator
  • getAllocated() : Loki::SimpleStatisticPolicy
  • getCreated() : Loki::SimpleStatisticPolicy
  • getDestroyed() : Loki::SimpleStatisticPolicy
  • getFetched() : Loki::SimpleStatisticPolicy
  • getHit() : Loki::SimpleStatisticPolicy
  • getLowerBound() : Loki::EvictionHelper< ST, DT >
  • GetMaxObjectSize() : Loki::SmallObjAllocator
  • getMissed() : Loki::SimpleStatisticPolicy
  • getOut() : Loki::SimpleStatisticPolicy
  • GetPointer()
: Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::Private::TwoRefCountInfo
, Loki::TwoRefCounts
, Loki::TwoRefLinks
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • GetPointerRef()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefLinks
, Loki::TwoRefCounts
  • GetPrototype() : Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
  • Go() : Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType > , Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • GracefulDelete() : Loki::DeletableSingleton< T >
  • GreaterThan() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- h -

  • H : Loki::Conversion< T, U >
  • HasBlock() : Loki::FixedAllocator
  • HasStrongPointer()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefCounts
  • HasWeakPointer() : Loki::Private::TwoRefCountInfo
  • head : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
  • Head : Loki::Typelist< T, U >
  • head_t : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
  • HeapStorage() : Loki::HeapStorage< T >
  • HitMap : Loki::EvictionHelper< ST, DT >
  • HitMapItr : Loki::EvictionHelper< ST, DT >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- i -

  • id : Loki::Key< Factory, IdentifierType >
  • Impl : Loki::Functor< R, TList, ThreadingModel > , Loki::Pimpl< T, Pointer > , Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > > , Loki::PimplOf< T, Ptr >
  • IncStrongCount() : Loki::Private::TwoRefCountInfo
  • IncWeakCount() : Loki::Private::TwoRefCountInfo
  • Initialize() : Loki::FixedAllocator
  • InitPointerType
: Loki::HeapStorage< T >
, Loki::LockedStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::ArrayStorage< T >
, Loki::FunctionStorage< T >
  • insert() : Loki::AssocVector< K, V, C, A >
  • Instance() : Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > , Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • int_ : Loki::CreateStatic< T >::MaxAlign
  • IntType : Loki::SingleThreaded< Host, MutexPolicy >
  • IsCorrupt()
: Loki::FixedAllocator
, Loki::SmallObjAllocator
  • IsCorrupted() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • isDead : Loki::DeletableSingleton< T >
  • IsStrong() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • iterator : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- p -

  • p1 : Loki::Key< Factory, IdentifierType >
  • p10 : Loki::Key< Factory, IdentifierType >
  • p11 : Loki::Key< Factory, IdentifierType >
  • p12 : Loki::Key< Factory, IdentifierType >
  • p13 : Loki::Key< Factory, IdentifierType >
  • p14 : Loki::Key< Factory, IdentifierType >
  • p15 : Loki::Key< Factory, IdentifierType >
  • p1_ : 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::ObjScopeGuardImpl1< Obj, MemFun, P1 > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • p2 : Loki::Key< Factory, IdentifierType >
  • p2_ : 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::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • p3 : Loki::Key< Factory, IdentifierType >
  • p3_ : Loki::ScopeGuardImpl3< F, P1, P2, P3 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • p4 : Loki::Key< Factory, IdentifierType >
  • p4_ : Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • p5 : Loki::Key< Factory, IdentifierType >
  • p5_ : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • p6 : Loki::Key< Factory, IdentifierType >
  • p7 : Loki::Key< Factory, IdentifierType >
  • p8 : Loki::Key< Factory, IdentifierType >
  • p9 : Loki::Key< Factory, IdentifierType >
  • Pair : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • ParameterType : Loki::TypeTraits< T >
  • ParamType : Loki::Visitor< T, R, false > , Loki::Visitor< T, R, true >
  • Parm1 : Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> , Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 > , Loki::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 >
  • Parm10 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > > >> , Loki::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 > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 >
  • Parm11 : Loki::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 > > > > > > > > > > > > > > >> , Loki::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 > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Functor< R, TList, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 >
  • Parm12 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Functor< R, TList, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 >
  • Parm13 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >
  • Parm14 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Functor< R, TList, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >
  • Parm15 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Chainer< Fun1, Fun2 > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImplBase , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >
  • Parm2 : Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::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 > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 >
  • Parm3 : Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::FactoryImplBase , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 >
  • Parm4 : Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 >
  • Parm5 : Loki::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 > > > > > > > > > > >> , Loki::Chainer< Fun1, Fun2 > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > >> , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FactoryImplBase , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::Functor< R, TList, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 >
  • Parm6 : Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::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 > > > > > > > > > > >> , Loki::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 > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::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 > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 > > > > > > >> , Loki::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 > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::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 > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Chainer< Fun1, Fun2 > , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FactoryImplBase , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 >
  • Parm7 : Loki::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 > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > > > > > > > > > > > >> , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::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 > , Loki::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 > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FactoryImplBase , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::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 > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::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 >
  • Parm8 : Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::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 > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > >> , Loki::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 > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >
  • Parm9 : Loki::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 > , Loki::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 > > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::Chainer< Fun1, Fun2 > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > >> , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > >> , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::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 >
  • ParmList : Loki::Functor< R, TList, ThreadingModel > , Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
  • pFun_ : Loki::Private::Adapter< T >
  • Pimpl() : Loki::Pimpl< T, Pointer >
  • pMember_ : Loki::CreateStatic< T >::MaxAlign
  • PointeeType : Loki::TypeTraits< T >
  • pointer : Loki::AssocVector< K, V, C, A >
  • PointerType
: Loki::DefaultSPStorage< T >
, Loki::FunctionStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::LockedStorage< T >
, Loki::HeapStorage< T >
, Loki::ArrayStorage< T >
  • PrintfState() : Loki::PrintfState< Device, Char >
  • ProductList
: Loki::AbstractFactory< TList, Unit >
, Loki::ConcreteFactory< AbstractFact, Creator, TList >
, Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
, Loki::OpNewFactoryUnit< ConcreteProduct, Base >
  • ProductReturn : Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::SimplePointer< AbstractProduct >
  • PrototypeFactoryUnit() : Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- r -

  • RateLimitedCreation() : Loki::RateLimitedCreation
  • rbegin() : Loki::AssocVector< K, V, C, A >
  • RefCounted() : Loki::RefCounted< P >
  • RefCountedMT() : Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
  • reference : Loki::AssocVector< K, V, C, A >
  • ReferenceType : Loki::HeapStorage< T > , Loki::ArrayStorage< T > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::LockedStorage< T > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::FunctionStorage< T > , Loki::DefaultSPStorage< T >
  • ReferredType : Loki::TypeTraits< T >
  • RefLinked() : Loki::RefLinked< P >
  • RefLinkedBase() : Loki::Private::RefLinkedBase
  • RefOrValue : Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > > , Loki::Private::BinderFirstBoundTypeStorage< T >
  • RefToValue() : Loki::RefToValue< T >
  • Register() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • RegisteredIds() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • registerObj : Loki::Private::RegisterOnCreateElement< T >
  • RegisterOnCreate() : Loki::Private::RegisterOnCreate< T >
  • RejectNull() : Loki::RejectNull< P >
  • RejectNullStatic() : Loki::RejectNullStatic< P >
  • RejectNullStrict() : Loki::RejectNullStrict< P >
  • Release()
: Loki::RefCounted< P >
, Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
, Loki::COMRefCounted< P >
, Loki::RefLinked< P >
, Loki::DeepCopy< P >
, Loki::NoCopy< P >
  • release() : Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • Release()
: Loki::TwoRefCounts
, Loki::DestructiveCopy< P >
  • release() : Loki::SimplePointer< AbstractProduct >
  • ReleaseObject() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • remove() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • Remove() : Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > , Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • rend() : Loki::AssocVector< K, V, C, A >
  • Result : Loki::TL::EraseAll< Typelist< Head, Tail >, T > , Loki::TL::Erase< NullType, T > , Loki::Private::AddReference< void > , Loki::TL::Append< Typelist< Head, Tail >, T > , Loki::TL::Erase< Typelist< T, Tail >, T > , Loki::TL::EraseAll< NullType, T > , Loki::Private::AddPointer< U > , Loki::TL::NoDuplicates< Typelist< Head, Tail > > , Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 > , Loki::TL::EraseAll< Typelist< T, Tail >, T > , Loki::TL::Replace< NullType, T, U > , Loki::TL::Erase< Typelist< Head, Tail >, T > , Loki::TL::ReplaceAll< NullType, T, U > , Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U > , Loki::TL::Reverse< NullType > , Loki::TL::Reverse< Typelist< Head, Tail > > , Loki::TL::MostDerived< NullType, T > , Loki::TL::MostDerived< Typelist< Head, Tail >, T > , Loki::TL::DerivedToFront< NullType > , Loki::TL::DerivedToFront< Typelist< Head, Tail > > , Loki::Select< flag, T, U > , Loki::Select< false, T, U > , Loki::Private::AddPointer< U & > , Loki::Private::AddReference< U > , Loki::Private::AddReference< U & > , Loki::Private::AddParameterType< U > , Loki::Private::AddParameterType< U & > , Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T > , Loki::Private::AddParameterType< void > , Loki::TL::Replace< Typelist< T, Tail >, T, U > , Loki::TL::Replace< Typelist< Head, Tail >, T, U > , Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U > , Loki::TL::NoDuplicates< NullType > , Loki::TL::Append< NullType, NullType > , Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType > , Loki::TL::TypeAtNonStrict< TList, index, DefaultType > , Loki::TL::MakeTypelist<> , Loki::TL::TypeAt< Typelist< Head, Tail >, i > , Loki::TL::TypeAt< Typelist< Head, Tail >, 0 > , Loki::TL::Append< NullType, Typelist< Head, Tail > > , Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType > , Loki::TL::Append< NullType, T >
  • ResultType : Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FieldHelper< H, 0 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FieldHelper< H, i > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::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 > , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::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 > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > , Loki::FunctorImpl< R, NullType, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::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 > , Loki::Functor< R, TList, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 >
  • ReturnType : Loki::Visitor< T, R, false > , Loki::Visitor< Typelist< Head, Tail >, R, false > , Loki::BaseVisitable< R, CatchAll, true > , Loki::Visitor< Typelist< Head, NullType >, R, true > , Loki::BaseVisitable< R, CatchAll, false > , Loki::CyclicVisitor< R, TList > , Loki::Visitor< Typelist< Head, Tail >, R, true > , Loki::Visitor< T, R, true > , Loki::Visitor< Typelist< Head, NullType >, R, false >
  • reverse_iterator : Loki::AssocVector< K, V, C, A >
  • RightBase : Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > , Loki::FieldHelper< H, i >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- s -

  • SafeExecute() : Loki::ScopeGuardImplBase
  • ScheduleDestruction()
: Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
, Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master >
, Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F >
, Loki::DefaultLifetime< T >
, Loki::PhoenixSingleton< T >
, Loki::DeletableSingleton< T >
, Loki::SingletonWithLongevity< T >
, Loki::NoDestroy< T >
  • ScopeGuardImpl0() : Loki::ScopeGuardImpl0< F >
  • ScopeGuardImpl1() : Loki::ScopeGuardImpl1< F, P1 >
  • ScopeGuardImpl2() : Loki::ScopeGuardImpl2< F, P1, P2 >
  • ScopeGuardImpl3() : Loki::ScopeGuardImpl3< F, P1, P2, P3 >
  • ScopeGuardImpl4() : Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
  • ScopeGuardImpl5() : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • ScopeGuardImplBase() : Loki::ScopeGuardImplBase
  • SetCallBackFunction() : Loki::FunctionStorage< T >
  • SetLongevity() : Loki::Private::OrderedStaticBase< T >
  • setMaxCreation() : Loki::AmountLimitedCreation
  • SetPointer()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefCounts
  • SetPrototype() : Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
  • setRate() : Loki::RateLimitedCreation
  • shortInt_ : Loki::CreateStatic< T >::MaxAlign
  • SimpleStatisticPolicy() : Loki::SimpleStatisticPolicy
  • size() : Loki::AssocVector< K, V, C, A >
  • size_type : Loki::AssocVector< K, V, C, A >
  • Small : Loki::Private::ConversionHelper< T, U >
  • SmallObjAllocator() : Loki::SmallObjAllocator
  • SmallObject() : Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • SmallObjectBase() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • SmallValueObject() : Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • SmartPointer() : Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • SmartPtr() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • StoredType
: Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::DefaultSPStorage< T >
, Loki::FunctionStorage< T >
, Loki::LockedStorage< T >
, Loki::ArrayStorage< T >
, Loki::HeapStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • StrongPtr() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • Swap() : Loki::DeleteSingle< P >
  • swap() : Loki::AssocVector< K, V, C, A >
  • Swap()
: Loki::DeleteUsingFree< P >
, Loki::DeleteNothing< P >
, Loki::AssertCheck< P >
, Loki::DeleteArray< P >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::AllowConversion
, Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
, Loki::AssertCheckStrict< P >
, Loki::RejectNull< P >
, Loki::DeepCopy< P >
, Loki::ArrayStorage< T >
, Loki::RejectNullStrict< P >
, Loki::FunctionStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::NoCopy< P >
, Loki::COMRefCounted< P >
, Loki::NoCheck< P >
, Loki::RejectNullStatic< P >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::HeapStorage< T >
, Loki::DisallowConversion
, Loki::DestructiveCopy< P >
, Loki::LockedStorage< T >
, Loki::RefCounted< P >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- t -

  • t_ : Loki::CreateStatic< T >::MaxAlign
  • tail : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
  • Tail : Loki::Typelist< T, U >
  • tail_t : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
  • TList : Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >
  • Trampoline() : Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback >
  • TrampolineR() : Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback >
  • TrimChunkList() : Loki::FixedAllocator
  • TrimEmptyChunk() : Loki::FixedAllocator
  • TrimExcessMemory() : Loki::SmallObjAllocator
  • TwoRefCountInfo() : Loki::Private::TwoRefCountInfo
  • TwoRefCounts() : Loki::TwoRefCounts
  • TwoRefLinks() : Loki::TwoRefLinks
  • Type
: Loki::RimplOf< T, UsedPimpl >
, Loki::Seq<>
, Loki::PropagateConst< T >
, Loki::DontPropagateConst< T >
  • type : Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • Type : Loki::PimplOf< T, Ptr > , Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > , Loki::Private::Deleter< T >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- u -

  • UnitType : Loki::FieldHelper< H, 0 > , Loki::FieldHelper< H, i >
  • Unlock() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::Mutex
  • UnqualifiedResultType : Loki::FieldHelper< H, i > , Loki::FieldHelper< H, 0 >
  • UnqualifiedType : Loki::TypeTraits< T >
  • Unregister() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • unregisterObj : Loki::Private::UnRegisterOnDeleteElement< T >
  • unspecified_bool_type : Loki::Functor< R, TList, ThreadingModel >
  • upper_bound() : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- v -

  • value_ : Loki::TupleUnit< T >
  • value_comp() : Loki::AssocVector< K, V, C, A >
  • value_compare() : Loki::AssocVector< K, V, C, A >::value_compare
  • value_type : Loki::AssocVector< K, V, C, A >
  • Visit() : Loki::BaseVisitorImpl< Typelist< Head, NullType >, R > , Loki::BaseVisitorImpl< Typelist< Head, Tail >, R >
  • VolatileType : Loki::SingleThreaded< Host, MutexPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

Here is a list of all documented class members with links to the class documentation for each member:

- w -

  • what()
: Loki::NeverCreate::Exception
, Loki::NullPointerException
, Loki::RateLimitedCreation::Exception
, Loki::CacheException
, Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception
, Loki::EvictionException
  • wrapped() : Loki::Pimpl< T, Pointer >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- a -

  • AcceptImpl()
: Loki::BaseVisitable< R, CatchAll, false >
, Loki::BaseVisitable< R, CatchAll, true >
  • Add() : Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > , Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • Allocate()
: Loki::FixedAllocator
, Loki::SmallObjAllocator
  • AllocatorSingleton() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • AmountLimitedCreation() : Loki::AmountLimitedCreation
  • ArrayStorage() : Loki::ArrayStorage< T >
  • AssertCheck() : Loki::AssertCheck< P >
  • AssertCheckStrict() : Loki::AssertCheckStrict< P >
  • AssocVector() : Loki::AssocVector< K, V, C, A >
  • AssocVectorCompare() : Loki::Private::AssocVectorCompare< Value, C >
  • atexitCallback() : Loki::DeletableSingleton< T >
  • AtomicAdd() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicAssign() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicDecrement() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicDivide() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicIncrement() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicMultiply() : Loki::SingleThreaded< Host, MutexPolicy >
  • AtomicSubtract() : Loki::SingleThreaded< Host, MutexPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- k -

  • Key() : Loki::Key< Factory, IdentifierType >
  • key_comp() : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- l -

  • LessThan() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • LifetimeTracker() : Loki::Private::LifetimeTracker
  • Lock() : Loki::SingleThreaded< Host, MutexPolicy >::Lock , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::Mutex , Loki::SingleThreaded< Host, MutexPolicy >::Lock
  • LockedStorage() : Loki::LockedStorage< T >
  • Locker() : Loki::Locker< T >
  • LockingPtr() : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • lower_bound() : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- m -

  • MakeGuard() : Loki::ScopeGuardImpl0< F > , Loki::ScopeGuardImpl1< F, P1 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ScopeGuardImpl2< F, P1, P2 > , Loki::ScopeGuardImpl3< F, P1, P2, P3 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
  • MakeObjGuard() : Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ObjScopeGuardImpl0< Obj, MemFun > , Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • max_size() : Loki::AssocVector< K, V, C, A >
  • MemFunHandler() : Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
  • Merge() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::RefLinked< P >
  • Mutex() : Loki::Mutex
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- n -

  • name()
: Loki::SimplePointer< AbstractProduct >
, Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
, Loki::NeverCreate
, Loki::RateLimitedCreation
, Loki::EvictRandom< DT, ST >
, Loki::NoStatisticPolicy
, Loki::AmountLimitedCreation
, Loki::SimpleStatisticPolicy
, Loki::AlwaysCreate
, Loki::EvictLRU< DT, ST >
, Loki::EvictAging< DT, ST >
  • NoCheck() : Loki::NoCheck< P >
  • NoCopy() : Loki::NoCopy< P >
  • NullPointerException() : Loki::NullPointerException
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- o -

  • ObjScopeGuardImpl0() : Loki::ObjScopeGuardImpl0< Obj, MemFun >
  • ObjScopeGuardImpl1() : Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
  • ObjScopeGuardImpl2() : Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
  • ObjScopeGuardImpl3() : Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • onCreate()
: Loki::EvictLRU< DT, ST >
, Loki::NoStatisticPolicy
, Loki::SimpleStatisticPolicy
, Loki::NeverCreate
, Loki::AlwaysCreate
, Loki::EvictAging< DT, ST >
, Loki::RateLimitedCreation
, Loki::EvictRandom< DT, ST >
, Loki::AmountLimitedCreation
  • OnDeadReference()
: Loki::DefaultLifetime< T >
, Loki::PhoenixSingleton< T >
, Loki::DeletableSingleton< T >
, Loki::SingletonWithLongevity< T >
, Loki::NoDestroy< T >
, Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
, Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master >
, Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F >
  • onDebug()
: Loki::SimpleStatisticPolicy
, Loki::NoStatisticPolicy
  • OnDefault()
: Loki::NoCheck< P >
, Loki::AssertCheck< P >
, Loki::AssertCheckStrict< P >
, Loki::RejectNullStatic< P >
, Loki::RejectNull< P >
  • OnDereference()
: Loki::NoCheck< P >
, Loki::AssertCheck< P >
, Loki::AssertCheckStrict< P >
, Loki::RejectNullStatic< P >
, Loki::RejectNull< P >
, Loki::RejectNullStrict< P >
  • onDestroy()
: Loki::AmountLimitedCreation
, Loki::NoStatisticPolicy
, Loki::SimpleStatisticPolicy
, Loki::NeverCreate
, Loki::EvictLRU< DT, ST >
, Loki::AlwaysCreate
, Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::RateLimitedCreation
  • onFetch()
: Loki::SimpleStatisticPolicy
, Loki::EvictLRU< DT, ST >
, Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::NoStatisticPolicy
  • OnInit()
: Loki::NoCheck< P >
, Loki::AssertCheck< P >
, Loki::AssertCheckStrict< P >
, Loki::RejectNullStatic< P >
, Loki::RejectNull< P >
, Loki::RejectNullStrict< P >
  • onRelease()
: Loki::SimpleStatisticPolicy
, Loki::EvictLRU< DT, ST >
, Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
, Loki::NoStatisticPolicy
  • OnReleaseAll()
: Loki::CantResetWithStrong< P >
, Loki::AllowReset< P >
, Loki::NeverReset< P >
  • OnResetAll()
: Loki::CantResetWithStrong< P >
, Loki::AllowReset< P >
, Loki::NeverReset< P >
  • OnUnknownType() : Loki::DefaultFactoryError< IdentifierType, AbstractProduct >
  • OnUnknownVisitor() : Loki::DefaultCatchAll< R, Visited >
  • operator *()
: Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
, Loki::Private::OrderedStaticBase< T >
, Loki::ConstPropPtr< T >
, Loki::Pimpl< T, Pointer >
, Loki::HeapStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::ArrayStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::FunctionStorage< T >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator AutomaticConversionResult() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator const T &() : Loki::TupleUnit< T >
  • operator delete() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • operator int() : Loki::PrintfState< Device, Char >
  • operator new() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • operator RefToValue() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator T &() : Loki::RefToValue< T > , Loki::TupleUnit< T >
  • operator T *() : Loki::Locker< T >
  • operator unspecified_bool_type() : Loki::Functor< R, TList, ThreadingModel >
  • operator unspecified_boolean_type() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator!() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator!=() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator()()
: Loki::PrintfState< Device, Char >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Chainer< Fun1, Fun2 >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::TL::IterateTypes< AtomicType, GenFunc >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::PrintfState< Device, Char >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::BinderFirst< OriginalFunctor >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::TL::nameof_type< T >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::PrintfState< Device, Char >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::TL::sizeof_type< T >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, std::less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > >
, Loki::BinderFirst< OriginalFunctor >
, Loki::PrintfState< Device, Char >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::Chainer< Fun1, Fun2 >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::PrintfState< Device, Char >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::AssocVector< K, V, C, A >::value_compare
, Loki::Private::Adapter< T >
, Loki::TL::IterateTypes< NullType, GenFunc >
, Loki::Chainer< Fun1, Fun2 >
, Loki::Functor< R, TList, ThreadingModel >
, std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::Chainer< Fun1, Fun2 >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::PrintfState< Device, Char >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Chainer< Fun1, Fun2 >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Chainer< Fun1, Fun2 >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Private::AssocVectorCompare< Value, C >
, Loki::Chainer< Fun1, Fun2 >
, Loki::BinderFirst< OriginalFunctor >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Functor< R, TList, ThreadingModel >
, Loki::Chainer< Fun1, Fun2 >
, Loki::BinderFirst< OriginalFunctor >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::BinderFirst< OriginalFunctor >
, Loki::Chainer< Fun1, Fun2 >
, Loki::PrintfState< Device, Char >
, Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
, Loki::BinderFirst< OriginalFunctor >
, Loki::PrintfState< Device, Char >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
, Loki::FunctorHandler< ParentFunctor, Fun >
  • operator->()
: Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::HeapStorage< T >
, Loki::LockedStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::Private::OrderedStaticBase< T >
, Loki::Pimpl< T, Pointer >
, Loki::ConstPropPtr< T >
, Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::Locker< T >
, Loki::ArrayStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::ConstPropPtr< T >
, Loki::Pimpl< T, Pointer >
, Loki::FunctionStorage< T >
  • operator<() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::AssocVector< K, V, C, A >
  • operator<=() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • operator=() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::Functor< R, TList, ThreadingModel > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > , Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::AssocVector< K, V, C, A >
  • operator==() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator>() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator>=() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • operator[]() : Loki::AssocVector< K, V, C, A >
  • OrderedStatic() : Loki::OrderedStatic< L, T, P1(*)() > , Loki::OrderedStatic< L, T, Loki::Seq< P1 > > , Loki::OrderedStatic< L, T, Loki::NullType >
  • OrderedStaticBase() : Loki::Private::OrderedStaticBase< T >
  • Owner() : Loki::RimplOf< T, UsedPimpl >::Owner
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- z -

  • ZapPointer()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefLinks
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- ~ -

  • ~AbstractFactoryUnit() : Loki::AbstractFactoryUnit< T >
  • ~AllocatorSingleton() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~BaseVisitable()
: Loki::BaseVisitable< R, CatchAll, false >
, Loki::BaseVisitable< R, CatchAll, true >
  • ~BaseVisitor() : Loki::BaseVisitor
  • ~CachedFactory() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • ~ConcreteLifetimeTracker() : Loki::Private::ConcreteLifetimeTracker< T, Destroyer >
  • ~ConstPropPtr() : Loki::ConstPropPtr< T >
  • ~EvictAging() : Loki::EvictAging< DT, ST >
  • ~EvictLRU() : Loki::EvictLRU< DT, ST >
  • ~EvictRandom() : Loki::EvictRandom< DT, ST >
  • ~Factory() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • ~FactoryImpl() : Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::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 > > > > > > > > > > >> , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> , Loki::FactoryImpl< AP, Id, NullType > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > > >> , Loki::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 > > > > > > > > > >>
  • ~FixedAllocator() : Loki::FixedAllocator
  • ~FunctorImplBase() : Loki::Private::FunctorImplBase< R, ThreadingModel >
  • ~LockedStorage() : Loki::LockedStorage< T >
  • ~Locker() : Loki::Locker< T >
  • ~LockingPtr() : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • ~Mutex() : Loki::Mutex
  • ~ObjScopeGuardImpl0() : Loki::ObjScopeGuardImpl0< Obj, MemFun >
  • ~ObjScopeGuardImpl1() : Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
  • ~ObjScopeGuardImpl2() : Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
  • ~ObjScopeGuardImpl3() : Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • ~OrderedStaticBase() : Loki::Private::OrderedStaticBase< T >
  • ~Pimpl() : Loki::Pimpl< T, Pointer >
  • ~PrintfState() : Loki::PrintfState< Device, Char >
  • ~ScopeGuardImpl0() : Loki::ScopeGuardImpl0< F >
  • ~ScopeGuardImpl1() : Loki::ScopeGuardImpl1< F, P1 >
  • ~ScopeGuardImpl2() : Loki::ScopeGuardImpl2< F, P1, P2 >
  • ~ScopeGuardImpl3() : Loki::ScopeGuardImpl3< F, P1, P2, P3 >
  • ~ScopeGuardImpl4() : Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
  • ~ScopeGuardImpl5() : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • ~ScopeGuardImplBase() : Loki::ScopeGuardImplBase
  • ~SingletonFixedLongevity() : Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
  • ~SmallObjAllocator() : Loki::SmallObjAllocator
  • ~SmallObject() : Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~SmallObjectBase() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~SmallValueObject() : Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ~SmartPointer() : Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • ~SmartPtr() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • ~StrongPtr() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • ~TwoRefCountInfo() : Loki::Private::TwoRefCountInfo
  • ~UnRegisterOnDelete() : Loki::Private::UnRegisterOnDelete< T >
  • ~Visitor()
: Loki::Visitor< T, R, true >
, Loki::Visitor< T, R, false >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- b -

  • begin() : Loki::AssocVector< K, V, C, A >
  • BinderFirst() : Loki::BinderFirst< OriginalFunctor >
  • BlockSize() : Loki::FixedAllocator
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- c -

  • CachedFactory() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • canCreate()
: Loki::NeverCreate
, Loki::AlwaysCreate
, Loki::RateLimitedCreation
, Loki::AmountLimitedCreation
  • Cast()
: Loki::StaticCaster< To, From >
, Loki::DynamicCaster< To, From >
  • Chainer() : Loki::Chainer< Fun1, Fun2 >
  • clear() : Loki::AssocVector< K, V, C, A >
  • ClearExtraMemory() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • Clone()
: Loki::DestructiveCopy< P >
, Loki::NoCopy< P >
, Loki::Private::FunctorImplBase< R, ThreadingModel >
, Loki::RefLinked< P >
, Loki::RefCounted< P >
, Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
, Loki::COMRefCounted< P >
, Loki::DeepCopy< P >
  • Compare() : Loki::Private::LifetimeTracker
  • COMRefCounted() : Loki::COMRefCounted< P >
  • ConcreteLifetimeTracker() : Loki::Private::ConcreteLifetimeTracker< T, Destroyer >
  • ConstPropPtr() : Loki::ConstPropPtr< T >
  • count() : Loki::AssocVector< K, V, C, A >
  • CountEmptyChunks() : Loki::FixedAllocator
  • Create()
: Loki::CreateStatic< T >
, Loki::AbstractFactory< TList, Unit >
, Loki::CreateUsingNew< T >
, Loki::CreateUsing< Alloc >::Allocator< T >
, Loki::CreateUsingMalloc< T >
  • CreateObject() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • createObject() : Loki::OrderedStatic< L, T, Loki::NullType >
  • CreateObject() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • createObject() : Loki::OrderedStatic< L, T, P1(*)() >
  • CreateObject() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • createObject() : Loki::OrderedStatic< L, T, Loki::Seq< P1 > >
  • CreateObject() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- d -

  • Deallocate()
: Loki::SmallObjAllocator
, Loki::FixedAllocator
  • DecStrongCount() : Loki::Private::TwoRefCountInfo
  • DecWeakCount() : Loki::Private::TwoRefCountInfo
  • DeepCopy() : Loki::DeepCopy< P >
  • Default()
: Loki::FunctionStorage< T >
, Loki::HeapStorage< T >
, Loki::DeleteUsingFree< P >
, Loki::DeleteNothing< P >
, Loki::DeleteSingle< P >
, Loki::DeleteArray< P >
, Loki::DefaultSPStorage< T >
, Loki::LockedStorage< T >
, Loki::ArrayStorage< T >
  • DefaultSPStorage() : Loki::DefaultSPStorage< T >
  • Delete()
: Loki::DeleteSingle< P >
, Loki::Private::Deleter< T >
, Loki::DeleteArray< P >
, Loki::DeleteUsingFree< P >
, Loki::DeleteNothing< P >
  • Destroy()
: Loki::ArrayStorage< T >
, Loki::CreateUsingMalloc< T >
, Loki::HeapStorage< T >
, Loki::CreateStatic< T >
, Loki::CreateUsingNew< T >
, Loki::DefaultSPStorage< T >
, Loki::CreateUsing< Alloc >::Allocator< T >
, Loki::LockedStorage< T >
, Loki::FunctionStorage< T >
  • DestructiveCopy() : Loki::DestructiveCopy< P >
  • DisallowConversion() : Loki::DisallowConversion
  • Dismiss() : Loki::ScopeGuardImplBase
  • displayCacheType() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • Do()
: Loki::FieldHelper< H, i >
, Loki::FieldHelper< H, 0 >
  • DoClone()
: Loki::BinderFirst< OriginalFunctor >
, Loki::FunctorHandler< ParentFunctor, Fun >
, Loki::Chainer< Fun1, Fun2 >
, Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
  • DoCreate()
: Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
, Loki::OpNewFactoryUnit< ConcreteProduct, Base >
  • DoDispatch() : Loki::Private::InvocationTraits< SomeLhs, SomeRhs, Executor, ResultType >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- e -

  • empty() : Loki::AssocVector< K, V, C, A >
  • encapsulate() : Loki::SimplePointer< AbstractProduct > , Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • end() : Loki::AssocVector< K, V, C, A >
  • equal_range() : Loki::AssocVector< K, V, C, A >
  • Equals() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • erase() : Loki::AssocVector< K, V, C, A >
  • evict()
: Loki::EvictLRU< DT, ST >
, Loki::EvictAging< DT, ST >
, Loki::EvictRandom< DT, ST >
  • EvictAging() : Loki::EvictAging< DT, ST >
  • Execute() : Loki::ScopeGuardImpl2< F, P1, P2 > , Loki::ScopeGuardImpl3< F, P1, P2, P3 > , Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ScopeGuardImpl0< F > , Loki::ScopeGuardImpl1< F, P1 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ObjScopeGuardImpl0< Obj, MemFun >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- f -

  • Factory() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • find() : Loki::AssocVector< K, V, C, A >
  • FixedAllocator() : Loki::FixedAllocator
  • Function() : Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R()> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> , Loki::Function< R()> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R(P01, P02, P03, P04, P05)> , Loki::Function< R(P01)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R()> , Loki::Function<> , Loki::Function< R(P01)> , Loki::Function<> , Loki::Function< R(P01, P02, P03)> , Loki::Function<> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R(P01, P02)> , Loki::Function< R()> , Loki::Function<> , Loki::Function< R(P01, P02)> , Loki::Function<> , Loki::Function< R()> , Loki::Function< R(P01, P02, P03)> , Loki::Function<>
  • FunctionStorage() : Loki::FunctionStorage< T >
  • Functor() : Loki::Functor< R, TList, ThreadingModel >
  • FunctorDispatcherHelper() : Loki::Private::FunctorDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Fun, SwapArgs >
  • FunctorHandler() : Loki::FunctorHandler< ParentFunctor, Fun >
  • FunctorImplBase() : Loki::Private::FunctorImplBase< R, ThreadingModel >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- g -

  • GenericVisit() : Loki::CyclicVisitor< R, TList >
  • GetAlignment() : Loki::SmallObjAllocator
  • getAllocated() : Loki::SimpleStatisticPolicy
  • getCreated() : Loki::SimpleStatisticPolicy
  • getDestroyed() : Loki::SimpleStatisticPolicy
  • getFetched() : Loki::SimpleStatisticPolicy
  • getHit() : Loki::SimpleStatisticPolicy
  • getLowerBound() : Loki::EvictionHelper< ST, DT >
  • GetMaxObjectSize() : Loki::SmallObjAllocator
  • getMissed() : Loki::SimpleStatisticPolicy
  • getOut() : Loki::SimpleStatisticPolicy
  • GetPointer()
: Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::Private::TwoRefCountInfo
, Loki::TwoRefCounts
, Loki::TwoRefLinks
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • GetPointerRef()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefLinks
, Loki::TwoRefCounts
  • GetPrototype() : Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
  • Go() : Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::StaticDispatcher< Executor, BaseLhs, TypesLhs, symmetric, BaseRhs, TypesRhs, ResultType > , Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • GracefulDelete() : Loki::DeletableSingleton< T >
  • GreaterThan() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- h -

  • HasBlock() : Loki::FixedAllocator
  • HasStrongPointer()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefCounts
  • HasWeakPointer() : Loki::Private::TwoRefCountInfo
  • HeapStorage() : Loki::HeapStorage< T >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- i -

  • IncStrongCount() : Loki::Private::TwoRefCountInfo
  • IncWeakCount() : Loki::Private::TwoRefCountInfo
  • Initialize() : Loki::FixedAllocator
  • insert() : Loki::AssocVector< K, V, C, A >
  • Instance() : Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > , Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • IsCorrupt()
: Loki::FixedAllocator
, Loki::SmallObjAllocator
  • IsCorrupted() : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • IsStrong() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- p -

  • Pimpl() : Loki::Pimpl< T, Pointer >
  • PrintfState() : Loki::PrintfState< Device, Char >
  • PrototypeFactoryUnit() : Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- r -

  • RateLimitedCreation() : Loki::RateLimitedCreation
  • rbegin() : Loki::AssocVector< K, V, C, A >
  • RefCounted() : Loki::RefCounted< P >
  • RefCountedMT() : Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
  • RefLinked() : Loki::RefLinked< P >
  • RefLinkedBase() : Loki::Private::RefLinkedBase
  • RefToValue() : Loki::RefToValue< T >
  • Register() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >
  • RegisteredIds() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
  • RegisterOnCreate() : Loki::Private::RegisterOnCreate< T >
  • RejectNull() : Loki::RejectNull< P >
  • RejectNullStatic() : Loki::RejectNullStatic< P >
  • RejectNullStrict() : Loki::RejectNullStrict< P >
  • release() : Loki::SimplePointer< AbstractProduct >
  • Release()
: Loki::TwoRefCounts
, Loki::DestructiveCopy< P >
, Loki::COMRefCounted< P >
, Loki::RefCounted< P >
, Loki::RefLinked< P >
, Loki::DeepCopy< P >
, Loki::NoCopy< P >
  • release() : Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • Release() : Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
  • ReleaseObject() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • Remove() : Loki::FunctorDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend > , Loki::BasicDispatcher< BaseLhs, BaseRhs, ResultType, CallbackType > , Loki::FnDispatcher< BaseLhs, BaseRhs, ResultType, CastingPolicy, DispatcherBackend >
  • remove() : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • rend() : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- s -

  • SafeExecute() : Loki::ScopeGuardImplBase
  • ScheduleDestruction()
: Loki::DefaultLifetime< T >
, Loki::PhoenixSingleton< T >
, Loki::DeletableSingleton< T >
, Loki::SingletonWithLongevity< T >
, Loki::NoDestroy< T >
, Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
, Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master >
, Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F >
  • ScopeGuardImpl0() : Loki::ScopeGuardImpl0< F >
  • ScopeGuardImpl1() : Loki::ScopeGuardImpl1< F, P1 >
  • ScopeGuardImpl2() : Loki::ScopeGuardImpl2< F, P1, P2 >
  • ScopeGuardImpl3() : Loki::ScopeGuardImpl3< F, P1, P2, P3 >
  • ScopeGuardImpl4() : Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
  • ScopeGuardImpl5() : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • ScopeGuardImplBase() : Loki::ScopeGuardImplBase
  • SetCallBackFunction() : Loki::FunctionStorage< T >
  • SetLongevity() : Loki::Private::OrderedStaticBase< T >
  • setMaxCreation() : Loki::AmountLimitedCreation
  • SetPointer()
: Loki::Private::TwoRefCountInfo
, Loki::TwoRefCounts
  • SetPrototype() : Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
  • setRate() : Loki::RateLimitedCreation
  • SimpleStatisticPolicy() : Loki::SimpleStatisticPolicy
  • size() : Loki::AssocVector< K, V, C, A >
  • SmallObjAllocator() : Loki::SmallObjAllocator
  • SmallObject() : Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • SmallObjectBase() : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • SmallValueObject() : Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • SmartPointer() : Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
  • SmartPtr() : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • StrongPtr() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • Swap()
: Loki::LockedStorage< T >
, Loki::RejectNull< P >
, Loki::RejectNullStatic< P >
, Loki::FunctionStorage< T >
, Loki::RefCounted< P >
, Loki::DeleteUsingFree< P >
, Loki::DefaultSPStorage< T >
, Loki::ArrayStorage< T >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::AllowConversion
, Loki::NoCopy< P >
, Loki::DisallowConversion
, Loki::AssertCheckStrict< P >
, Loki::AssertCheck< P >
, Loki::DeepCopy< P >
, Loki::NoCheck< P >
, Loki::DeleteArray< P >
  • swap() : Loki::AssocVector< K, V, C, A >
  • Swap()
: Loki::DeleteSingle< P >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::RefCountedMTAdj< ThreadingModel, MX >::RefCountedMT< P >
, Loki::COMRefCounted< P >
, Loki::RejectNullStrict< P >
, Loki::HeapStorage< T >
, Loki::DestructiveCopy< P >
, Loki::DeleteNothing< P >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- t -

  • Trampoline() : Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback >
  • TrampolineR() : Loki::Private::FnDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, ResultType, CastLhs, CastRhs, Callback >
  • TrimChunkList() : Loki::FixedAllocator
  • TrimEmptyChunk() : Loki::FixedAllocator
  • TrimExcessMemory() : Loki::SmallObjAllocator
  • TwoRefCountInfo() : Loki::Private::TwoRefCountInfo
  • TwoRefCounts() : Loki::TwoRefCounts
  • TwoRefLinks() : Loki::TwoRefLinks
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- u -

  • Unlock() : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > , Loki::Mutex
  • Unregister() : Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > , Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > , Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
  • upper_bound() : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- v -

  • value_comp() : Loki::AssocVector< K, V, C, A >
  • value_compare() : Loki::AssocVector< K, V, C, A >::value_compare
  • Visit() : Loki::BaseVisitorImpl< Typelist< Head, Tail >, R > , Loki::BaseVisitorImpl< Typelist< Head, NullType >, R >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • z
  • ~

- w -

  • what()
: Loki::NeverCreate::Exception
, Loki::NullPointerException
, Loki::RateLimitedCreation::Exception
, Loki::CacheException
, Loki::DefaultFactoryError< IdentifierType, AbstractProduct >::Exception
, Loki::EvictionException
  • wrapped() : Loki::Pimpl< T, Pointer >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Related Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions

  • AssocVector : Loki::AssocVector< K, V, C, A >::value_compare
  • FixedAllocator : Loki::Chunk
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- a -

  • AbstractProduct : Loki::OpNewFactoryUnit< ConcreteProduct, Base > , Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
  • allocator_type : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- k -

  • key_compare : Loki::AssocVector< K, V, C, A >
  • key_type : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- l -

  • LeftBase : Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > , Loki::FieldHelper< H, 0 >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- m -

  • mapped_type : Loki::AssocVector< K, V, C, A >
  • MyAllocator : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • MyAllocatorSingleton : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • MyThreadingModel : Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- n -

  • NonConstType : Loki::TypeTraits< T >
  • NonVolatileType : Loki::TypeTraits< T >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- o -

  • ObjAllocatorSingleton : Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
  • ObjectType : Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >
  • OP : Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • OriginalFunctor : Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > > , Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > >
  • OriginalParm1 : Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
  • OriginalType : Loki::Type2Type< T >
  • Owner : Loki::PimplOf< T, Ptr >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- b -

  • BoundFunctorType : Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- c -

  • ConcreteProductList : Loki::ConcreteFactory< AbstractFact, Creator, TList >
  • const_iterator : Loki::AssocVector< K, V, C, A >
  • const_pointer : Loki::AssocVector< K, V, C, A >
  • const_reference : Loki::AssocVector< K, V, C, A >
  • const_reverse_iterator : Loki::AssocVector< K, V, C, A >
  • ConstLeftBase : Loki::FieldHelper< H, 0 >
  • ConstOrNotType : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • ConstPointerType : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • ConstReferenceType : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > , Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • ConstRightBase : Loki::FieldHelper< H, i >
  • CopyArg : Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
  • Creator : Loki::Private::OrderedStaticManagerClass
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- d -

  • difference_type : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- e -

  • ElementType : Loki::FieldHelper< H, 0 > , Loki::FieldHelper< H, i >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- f -

  • FBase : Loki::Function< R()> , Loki::Function<> , Loki::Function< R(P01, P02)> , Loki::Function< R(P01, P02, P03, P04, P05, P06)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> , Loki::Function< R(P01, P02, P03, P04, P05, P06, P07)> , Loki::Function< R(P01, P02, P03)> , Loki::Function< R(P01, P02, P03, P04, P05)> , Loki::Function< R(P01, P02, P03, P04)> , Loki::Function< R(P01)>
  • Func : Loki::OrderedStatic< L, T, P1(*)() >
  • FunctorImplBaseType : Loki::Private::FunctorImplBase< R, ThreadingModel >
  • FunctorType : Loki::FunctionStorage< T >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- h -

  • H : Loki::Conversion< T, U >
  • Head : Loki::Typelist< T, U >
  • head_t : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
  • HitMap : Loki::EvictionHelper< ST, DT >
  • HitMapItr : Loki::EvictionHelper< ST, DT >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- i -

  • Impl
: Loki::Functor< R, TList, ThreadingModel >
, Loki::Pimpl< T, Pointer >
, Loki::PimplOf< T, Ptr >
, Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > >
  • InitPointerType
: Loki::LockedStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::ArrayStorage< T >
, Loki::FunctionStorage< T >
, Loki::HeapStorage< T >
  • IntType : Loki::SingleThreaded< Host, MutexPolicy >
  • iterator : Loki::AssocVector< K, V, C, A >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- p -

  • Pair : Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
  • ParameterType : Loki::TypeTraits< T >
  • ParamType : Loki::Visitor< T, R, false > , Loki::Visitor< T, R, true >
  • Parm1 : Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> , Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 > , Loki::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 >
  • Parm10 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > > >> , Loki::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 > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 >
  • Parm11 : Loki::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 > > > > > > > > > > > > > > >> , Loki::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 > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Functor< R, TList, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 >
  • Parm12 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Functor< R, TList, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 >
  • Parm13 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >
  • Parm14 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Functor< R, TList, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >
  • Parm15 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Chainer< Fun1, Fun2 > , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >
  • Parm2 : Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::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 > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > > >> , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 >
  • Parm3 : Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::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 > , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FactoryImplBase , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 >
  • Parm4 : Loki::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 > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::Functor< R, TList, ThreadingModel > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::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 > > > > > > > > > >> , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > > > >> , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > > > > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 >
  • Parm5 : Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::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 > > > > > > > > > > > > > > >> , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::Functor< R, TList, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > > > >> , Loki::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 > > > > > > > > > > >> , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::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 > > > > > > > > >> , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > > > >> , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > , Loki::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 > , Loki::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 >
  • Parm6 : Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::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 > > > > > > > > > > >> , Loki::Functor< R, TList, ThreadingModel > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::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 > > > > > > > > > >> , Loki::FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 > > > > > > > > >> , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > , Loki::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 > > > > > > > > > > > > >> , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > > > > > >> , Loki::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 >
  • Parm7 : Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::Functor< R, TList, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::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 > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FactoryImplBase , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > >> , Loki::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 > > > > > > > > > > > >> , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::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 > > > > > > > > > > > > > >> , Loki::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 > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::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 > , Loki::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 > , Loki::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 > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > , Loki::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 >
  • Parm8 : Loki::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 > , Loki::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 > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > , Loki::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 > > > > > > > > > > >> , Loki::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 > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::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 > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::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 > > > > > > > > > > > > >> , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::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 > , Loki::FactoryImplBase , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > > > > > > > > > >> , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::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 > > > > > > > > > > > >> , Loki::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 > > > > > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::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 > > > > > > > > >> , Loki::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 >
  • Parm9 : Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::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 > > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::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 > , Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > >> , Loki::Functor< R, TList, ThreadingModel > , Loki::FactoryImplBase , Loki::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 > , Loki::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 > , Loki::Chainer< Fun1, Fun2 > , Loki::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 > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > , Loki::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 > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > > > >> , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 > , Loki::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 > > > > > > > > > > > > > > >> , Loki::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 > > > > > > > > > >> , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > , Loki::FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::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 > > > > > > > > > > > > > >>
  • ParmList : Loki::Private::BinderFirstTraits< Functor< R, TList, ThreadingModel > > , Loki::Functor< R, TList, ThreadingModel >
  • PointeeType : Loki::TypeTraits< T >
  • pointer : Loki::AssocVector< K, V, C, A >
  • PointerType
: Loki::DefaultSPStorage< T >
, Loki::FunctionStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::HeapStorage< T >
, Loki::ArrayStorage< T >
, Loki::LockedStorage< T >
  • ProductList
: Loki::OpNewFactoryUnit< ConcreteProduct, Base >
, Loki::PrototypeFactoryUnit< ConcreteProduct, Base >
, Loki::AbstractFactory< TList, Unit >
, Loki::ConcreteFactory< AbstractFact, Creator, TList >
  • ProductReturn : Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > , Loki::SimplePointer< AbstractProduct > , Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- r -

  • reference : Loki::AssocVector< K, V, C, A >
  • ReferenceType
: Loki::HeapStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::LockedStorage< T >
, Loki::ArrayStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::FunctionStorage< T >
, Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
  • ReferredType : Loki::TypeTraits< T >
  • RefOrValue : Loki::Private::BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > > , Loki::Private::BinderFirstBoundTypeStorage< T >
  • Result : Loki::TL::Erase< NullType, T > , Loki::TL::Erase< Typelist< T, Tail >, T > , Loki::Private::AddParameterType< U > , Loki::TL::Erase< Typelist< Head, Tail >, T > , Loki::TL::EraseAll< NullType, T > , Loki::TL::EraseAll< Typelist< T, Tail >, T > , Loki::Private::AddPointer< U & > , Loki::TL::EraseAll< Typelist< Head, Tail >, T > , Loki::TL::NoDuplicates< NullType > , Loki::TL::NoDuplicates< Typelist< Head, Tail > > , Loki::TL::Replace< NullType, T, U > , Loki::TL::Replace< Typelist< T, Tail >, T, U > , Loki::TL::Replace< Typelist< Head, Tail >, T, U > , Loki::TL::ReplaceAll< NullType, T, U > , Loki::TL::ReplaceAll< Typelist< T, Tail >, T, U > , Loki::TL::ReplaceAll< Typelist< Head, Tail >, T, U > , Loki::TL::Reverse< NullType > , Loki::TL::Reverse< Typelist< Head, Tail > > , Loki::TL::MostDerived< NullType, T > , Loki::TL::MostDerived< Typelist< Head, Tail >, T > , Loki::TL::DerivedToFront< NullType > , Loki::TL::DerivedToFront< Typelist< Head, Tail > > , Loki::Select< flag, T, U > , Loki::Select< false, T, U > , Loki::Private::AddPointer< U > , Loki::Private::AddReference< U > , Loki::Private::AddReference< U & > , Loki::Private::AddReference< void > , Loki::Private::AddParameterType< U & > , Loki::Private::AddParameterType< void > , Loki::TL::Append< Typelist< Head, Tail >, T > , Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind< T > , Loki::TL::MakeTypelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 > , Loki::TL::MakeTypelist<> , Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType > , Loki::TL::TypeAt< Typelist< Head, Tail >, 0 > , Loki::TL::TypeAt< Typelist< Head, Tail >, i > , Loki::TL::TypeAtNonStrict< TList, index, DefaultType > , Loki::TL::TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType > , Loki::TL::Append< NullType, NullType > , Loki::TL::Append< NullType, T > , Loki::TL::Append< NullType, Typelist< Head, Tail > >
  • ResultType : Loki::Private::FunctorImplBase< R, ThreadingModel > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > , Loki::FieldHelper< H, 0 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > , Loki::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 > , Loki::FunctorHandler< ParentFunctor, Fun > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > , Loki::Chainer< Fun1, Fun2 > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > , Loki::FunctorImpl< R, NullType, ThreadingModel > , Loki::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > , Loki::FieldHelper< H, i > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1 >, ThreadingModel > , Loki::Functor< R, TList, ThreadingModel > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > , Loki::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 > , Loki::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 > , Loki::FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > , Loki::FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > , Loki::FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > , Loki::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 >
  • ReturnType : Loki::Visitor< Typelist< Head, Tail >, R, true > , Loki::CyclicVisitor< R, TList > , Loki::Visitor< Typelist< Head, Tail >, R, false > , Loki::Visitor< T, R, true > , Loki::Visitor< Typelist< Head, NullType >, R, true > , Loki::Visitor< T, R, false > , Loki::BaseVisitable< R, CatchAll, false > , Loki::Visitor< Typelist< Head, NullType >, R, false > , Loki::BaseVisitable< R, CatchAll, true >
  • reverse_iterator : Loki::AssocVector< K, V, C, A >
  • RightBase : Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit > , Loki::FieldHelper< H, i >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- s -

  • size_type : Loki::AssocVector< K, V, C, A >
  • Small : Loki::Private::ConversionHelper< T, U >
  • StoredType
: Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
, Loki::FunctionStorage< T >
, Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
, Loki::ArrayStorage< T >
, Loki::HeapStorage< T >
, Loki::DefaultSPStorage< T >
, Loki::LockedStorage< T >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- t -

  • Tail : Loki::Typelist< T, U >
  • tail_t : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >
  • TList : Loki::GenScatterHierarchy< Typelist< T1, T2 >, Unit >
  • Type
: Loki::Private::Deleter< T >
, Loki::Seq<>
, Loki::Seq< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 >
, Loki::RimplOf< T, UsedPimpl >
, Loki::PimplOf< T, Ptr >
, Loki::PropagateConst< T >
, Loki::DontPropagateConst< T >
  • type : Loki::SmartPtrDef< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- u -

  • UnitType : Loki::FieldHelper< H, 0 > , Loki::FieldHelper< H, i >
  • UnqualifiedResultType : Loki::FieldHelper< H, i > , Loki::FieldHelper< H, 0 >
  • UnqualifiedType : Loki::TypeTraits< T >
  • unspecified_bool_type : Loki::Functor< R, TList, ThreadingModel >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- v -

  • value_type : Loki::AssocVector< K, V, C, A >
  • VolatileType : Loki::SingleThreaded< Host, MutexPolicy >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Related Functions
  • a
  • c
  • d
  • f
  • h
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v

- a -

  • allocator : Loki::CreateUsing< Alloc >::Allocator< T >

- c -

  • count : Loki::Key< Factory, IdentifierType >

- d -

  • d : Loki::PimplOwner< T, Pointer > , Loki::RimplOf< T, UsedPimpl >::Owner
  • deleter : Loki::DeletableSingleton< T >
  • dismissed_ : Loki::ScopeGuardImplBase
  • double_ : Loki::CreateStatic< T >::MaxAlign
  • dummy : Loki::Private::ConversionHelper< T, U >::Big

- f -

  • float_ : Loki::CreateStatic< T >::MaxAlign
  • fun_ : Loki::ScopeGuardImpl2< F, P1, P2 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ScopeGuardImpl3< F, P1, P2, P3 > , Loki::ScopeGuardImpl0< F > , Loki::ScopeGuardImpl1< F, P1 >

- h -

  • head : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >

- i -

  • id : Loki::Key< Factory, IdentifierType >
  • int_ : Loki::CreateStatic< T >::MaxAlign
  • isDead : Loki::DeletableSingleton< T >

- l -

  • longDouble_ : Loki::CreateStatic< T >::MaxAlign
  • longInt_ : Loki::CreateStatic< T >::MaxAlign

- m -

  • m_mHitCount : Loki::EvictionHelper< ST, DT >
  • memFun_ : Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > , Loki::ObjScopeGuardImpl0< Obj, MemFun >

- n -

  • needCallback : Loki::DeletableSingleton< T >

- o -

  • obj_ : Loki::ObjScopeGuardImpl0< Obj, MemFun > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >

- p -

  • p1 : Loki::Key< Factory, IdentifierType >
  • p10 : Loki::Key< Factory, IdentifierType >
  • p11 : Loki::Key< Factory, IdentifierType >
  • p12 : Loki::Key< Factory, IdentifierType >
  • p13 : Loki::Key< Factory, IdentifierType >
  • p14 : Loki::Key< Factory, IdentifierType >
  • p15 : Loki::Key< Factory, IdentifierType >
  • p1_ : Loki::ScopeGuardImpl1< F, P1 > , Loki::ScopeGuardImpl2< F, P1, P2 > , Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ScopeGuardImpl3< F, P1, P2, P3 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
  • p2 : Loki::Key< Factory, IdentifierType >
  • p2_ : Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > , 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::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
  • p3 : Loki::Key< Factory, IdentifierType >
  • p3_ : Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > , Loki::ScopeGuardImpl3< F, P1, P2, P3 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > , Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • p4 : Loki::Key< Factory, IdentifierType >
  • p4_ : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > , Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
  • p5 : Loki::Key< Factory, IdentifierType >
  • p5_ : Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
  • p6 : Loki::Key< Factory, IdentifierType >
  • p7 : Loki::Key< Factory, IdentifierType >
  • p8 : Loki::Key< Factory, IdentifierType >
  • p9 : Loki::Key< Factory, IdentifierType >
  • pFun_ : Loki::Private::Adapter< T >
  • pMember_ : Loki::CreateStatic< T >::MaxAlign

- r -

  • registerObj : Loki::Private::RegisterOnCreateElement< T >

- s -

  • shortInt_ : Loki::CreateStatic< T >::MaxAlign

- t -

  • t_ : Loki::CreateStatic< T >::MaxAlign
  • tail : Loki::TL::IterateTypes< Typelist< T1, T2 >, GenFunc >

- u -

  • unregisterObj : Loki::Private::UnRegisterOnDeleteElement< T >

- v -

  • value_ : Loki::TupleUnit< T >
Generated on Sat Jul 7 15:11:10 2007 for Loki by doxygen 1.5.1-p1


Loki: Graphical Class Hierarchy

Loki Graphical Class Hierarchy

Go to the textual class hierarchy

Generated on Sat Jul 7 15:11:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Namespace Index

  • Namespace List
  • Namespace Members

Loki Namespace List

Here is a list of all documented namespaces with brief descriptions:
Loki |
Loki::LongevityLifetime |
Loki::Private |
Loki::TL |
LongevityLifetime | In this namespace are special lifetime policies to manage lifetime dependencies
std |
Generated on Sat Jul 7 15:11:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki Namespace Reference

  • Namespace List
  • Namespace Members

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 ScopeGuardImplBase & | ScopeGuard
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 Sat Jul 7 15:11:42 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::LongevityLifetime Namespace Reference

  • Namespace List
  • Namespace Members
Loki::LongevityLifetime

Loki::LongevityLifetime Namespace Reference

Classes

struct | SingletonFixedLongevity
struct | DieLast
Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF. More...
struct | DieDirectlyBeforeLast
Lifetime is a one less than DieLast: 0xFFFFFFFF-1. More...
struct | DieFirst
Shortest possible SingletonWithLongevity lifetime: 0. More...
struct | DieAsSmallObjectParent
struct | DieAsSmallObjectChild

Generated on Sat Jul 7 15:12:34 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::Private Namespace Reference

  • Namespace List
  • Namespace Members
Loki::Private

Loki::Private Namespace Reference

Classes

class | AssocVectorCompare
struct | FunctorImplBase
struct | BinderFirstTraits< Functor< R, TList, ThreadingModel > >
struct | BinderFirstBoundTypeStorage
struct | BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > >
struct | InvocationTraits
struct | FnDispatcherHelper
class | FunctorDispatcherHelper
class | OrderedStaticCreatorFunc
class | OrderedStaticBase
class | OrderedStaticManagerClass
struct | RegisterOnCreate
struct | UnRegisterOnDelete
struct | RegisterOnCreateElement
struct | UnRegisterOnDeleteElement
class | LifetimeTracker
struct | Deleter
class | ConcreteLifetimeTracker
struct | Adapter
class | RefLinkedBase
class | TwoRefCountInfo
struct | ConversionHelper
struct | AddPointer
struct | AddPointer< U & >
struct | AddReference
struct | AddReference< U & >
struct | AddReference< void >
struct | AddParameterType
struct | AddParameterType< U & >
struct | AddParameterType< void >
struct | IsFunctionPointerRaw
struct | IsFunctionPointerRaw< T(*)()>
struct | IsFunctionPointerRaw< T(*)(P01)>
struct | IsFunctionPointerRaw< T(*)(P01, P02)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>
struct | IsFunctionPointerRaw< T(*)(...)>
struct | IsFunctionPointerRaw< T(*)(P01,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>
struct | IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>
struct | IsMemberFunctionPointerRaw
struct | IsMemberFunctionPointerRaw< T(S::*)()>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>
struct | IsMemberFunctionPointerRaw< T(S::*)(...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)>
struct | IsMemberFunctionPointerRaw< T(S::*)() const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const >
struct | IsMemberFunctionPointerRaw< T(S::*)() volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)() const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile >
struct | IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile >

Typedefs

typedef std::list< LifetimeTracker * > | TrackerArray
typedef ::Loki::Typelist<
unsigned char,::Loki::Typelist<
unsigned short int,::Loki::Typelist<
unsigned int,::Loki::Typelist<
unsigned long int,::Loki::NullType > > > > 		StdUnsignedInts
typedef ::Loki::Typelist<
signed char,::Loki::Typelist<
short int,::Loki::Typelist<
int,::Loki::Typelist< long
int,::Loki::NullType > > > > 		StdSignedInts
typedef ::Loki::Typelist<
bool,::Loki::Typelist< char,
::Loki::Typelist< wchar_t,
::Loki::NullType > > > 		StdOtherInts
typedef ::Loki::Typelist<
float,::Loki::Typelist< double,
::Loki::Typelist< long double,
::Loki::NullType > > > 		StdFloats

Functions

void | AtExitFn ()
void LOKI_C_CALLING_CONVENTION_QUALIFIER | AtExitFn ()

Variables

TrackerArray * pTrackerArray

Generated on Sat Jul 7 15:12:35 2007 for Loki by doxygen 1.5.1-p1


Loki: Loki::TL Namespace Reference

  • Namespace List
  • Namespace Members
Loki::TL

Loki::TL Namespace Reference

Classes

struct | nameof_type
struct | sizeof_type
struct | IterateTypes< Typelist< T1, T2 >, GenFunc >
struct | IterateTypes
struct | IterateTypes< NullType, GenFunc >
struct | MakeTypelist
struct | MakeTypelist<>
struct | Length< NullType >
struct | Length< Typelist< T, U > >
struct | TypeAt< Typelist< Head, Tail >, 0 >
struct | TypeAt< Typelist< Head, Tail >, i >
struct | TypeAtNonStrict
struct | TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType >
struct | TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType >
struct | IndexOf< NullType, T >
struct | IndexOf< Typelist< T, Tail >, T >
struct | IndexOf< Typelist< Head, Tail >, T >
struct | Append< NullType, NullType >
struct | Append< NullType, T >
struct | Append< NullType, Typelist< Head, Tail > >
struct | Append< Typelist< Head, Tail >, T >
struct | Erase< NullType, T >
struct | Erase< Typelist< T, Tail >, T >
struct | Erase< Typelist< Head, Tail >, T >
struct | EraseAll< NullType, T >
struct | EraseAll< Typelist< T, Tail >, T >
struct | EraseAll< Typelist< Head, Tail >, T >
struct | NoDuplicates< NullType >
struct | NoDuplicates< Typelist< Head, Tail > >
struct | Replace< NullType, T, U >
struct | Replace< Typelist< T, Tail >, T, U >
struct | Replace< Typelist< Head, Tail >, T, U >
struct | ReplaceAll< NullType, T, U >
struct | ReplaceAll< Typelist< T, Tail >, T, U >
struct | ReplaceAll< Typelist< Head, Tail >, T, U >
struct | Reverse< NullType >
struct | Reverse< Typelist< Head, Tail > >
struct | MostDerived< NullType, T >
struct | MostDerived< Typelist< Head, Tail >, T >
struct | DerivedToFront< NullType >
struct | DerivedToFront< Typelist< Head, Tail > >

Functions

template<typename Types, template< class > class UnitFunc, typename II>
void | iterate_types (II ii)

Generated on Sat Jul 7 15:12:45 2007 for Loki by doxygen 1.5.1-p1


Loki: LongevityLifetime Namespace Reference

  • Namespace List
  • Namespace Members

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 Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: std Namespace Reference

  • Namespace List
  • Namespace Members

std Namespace Reference
[Smart pointers]

Classes

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

Detailed Description

specialization of std::less for SmartPtr

Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Typedefs
  • a
  • b
  • c
  • d
  • f
  • g
  • i
  • m
  • o
  • r
  • s
  • t
  • u
  • w
  • x

Here is a list of all documented namespace members with links to the namespaces they belong to:

- a -

  • atexit_pfn_t : Loki
  • AtExitFn() : Loki::Private

- b -

  • BindFirst() : Loki
  • BufPrintf() : Loki
  • ByRef() : Loki

- c -

  • Chain() : Loki

- d -

  • DefaultAllocator() : Loki
  • DefaultDeallocator() : Loki
  • DoGetPrototype() : Loki
  • DoSetPrototype() : Loki

- f -

  • Field() : Loki

- g -

  • GetImpl() : Loki
  • GetImplRef() : Loki
  • GetLongevity() : Loki
  • GetOffset() : Loki

- i -

  • iterate_types() : Loki::TL

- m -

  • MakeGuard() : Loki
  • MakeObjGuard() : Loki

- o -

  • operator!=() : Loki
  • operator<() : Loki
  • operator<=() : Loki
  • operator==() : Loki
  • operator>() : Loki
  • operator>=() : Loki
  • OrderedStaticManager : Loki

- r -

  • RegisterFunction() : Loki
  • Release() : Loki
  • ReleaseAll() : Loki
  • Reset() : Loki
  • ResetAll() : Loki

- s -

  • ScopeGuard : Loki
  • SetLongevity() : Loki
  • StdFloats : Loki::Private
  • StdOtherInts : Loki::Private
  • StdSignedInts : Loki::Private
  • StdUnsignedInts : Loki::Private
  • swap() : Loki

- t -

  • TrackerArray : Loki::Private

- u -

  • UnRegisterFunction() : Loki

- w -

  • write() : Loki

- x -

  • XPrintf() : Loki
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Typedefs
  • a
  • b
  • c
  • d
  • f
  • g
  • i
  • m
  • o
  • r
  • s
  • u
  • w
  • x

- a -

  • AtExitFn() : Loki::Private

- b -

  • BindFirst() : Loki
  • BufPrintf() : Loki
  • ByRef() : Loki

- c -

  • Chain() : Loki

- d -

  • DefaultAllocator() : Loki
  • DefaultDeallocator() : Loki
  • DoGetPrototype() : Loki
  • DoSetPrototype() : Loki

- f -

  • Field() : Loki

- g -

  • GetImpl() : Loki
  • GetImplRef() : Loki
  • GetLongevity() : Loki
  • GetOffset() : Loki

- i -

  • iterate_types() : Loki::TL

- m -

  • MakeGuard() : Loki
  • MakeObjGuard() : Loki

- o -

  • operator!=() : Loki
  • operator<() : Loki
  • operator<=() : Loki
  • operator==() : Loki
  • operator>() : Loki
  • operator>=() : Loki

- r -

  • RegisterFunction() : Loki
  • Release() : Loki
  • ReleaseAll() : Loki
  • Reset() : Loki
  • ResetAll() : Loki

- s -

  • SetLongevity() : Loki
  • swap() : Loki

- u -

  • UnRegisterFunction() : Loki

- w -

  • write() : Loki

- x -

  • XPrintf() : Loki
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Typedefs

  • atexit_pfn_t : Loki
  • OrderedStaticManager : Loki
  • ScopeGuard : Loki
  • StdFloats : Loki::Private
  • StdOtherInts : Loki::Private
  • StdSignedInts : Loki::Private
  • StdUnsignedInts : Loki::Private
  • TrackerArray : Loki::Private
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: File Index

Loki File List

Here is a list of all documented files with brief descriptions:
AbstractFactory.h [code]
AssocVector.h [code]
CachedFactory.h [code]
ConstPolicy.h [code]
DataGenerators.h [code]
EmptyType.h [code]
Factory.h [code]
Function.h [code]
Functor.h [code]
HierarchyGenerators.h [code]
Key.h [code]
LockingPtr.h [code]
LokiExport.h [code]
LokiTypeInfo.h [code]
MultiMethods.h [code]
NullType.h [code]
OrderedStatic.cpp [code]
OrderedStatic.h [code]
Pimpl.h [code]
RefToValue.h [code]
Register.h [code]
SafeFormat.cpp [code]
SafeFormat.h [code]
ScopeGuard.h [code]
Sequence.h [code]
Singleton.cpp [code]
Singleton.h [code]
SmallObj.cpp [code]
SmallObj.h [code]
SmartPtr.cpp [code]
SmartPtr.h [code]
SPCachedFactory.h [code]
static_check.h [code]
StrongPtr.cpp [code]
StrongPtr.h [code]
Threads.h [code]
Tuple.h [code]
Typelist.h [code]
TypelistMacros.h [code]
TypeManip.h [code]
TypeTraits.h [code]
Visitor.h [code]
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Alphabetical List

Loki Class Index

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

A
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05)> (Loki::Private)
AbstractFactory IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const > (Loki::Private)
AbstractFactory (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) const volatile > (Loki::Private)
AbstractFactoryUnit (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06) volatile > (Loki::Private)
Adapter (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06)> (Loki::Private)
AddParameterType (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const > (Loki::Private)
AddParameterType< U & > (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) const volatile > (Loki::Private)
AddParameterType< void > (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07) volatile > (Loki::Private)
AddPointer (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07)> (Loki::Private)
AddPointer< U & > (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const > (Loki::Private)
AddReference (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) const volatile > (Loki::Private)
AddReference< U & > (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08) volatile > (Loki::Private)
AddReference< void > (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08)> (Loki::Private)
AllocatorSingleton (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const > (Loki::Private)
AllowConversion (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) const volatile > (Loki::Private)
AllowReset (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09) volatile > (Loki::Private)
AlwaysCreate (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> (Loki::Private)
AmountLimitedCreation (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const > (Loki::Private)
Append< NullType, NullType > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) const volatile > (Loki::Private)
Append< NullType, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10) volatile > (Loki::Private)
Append< NullType, Typelist< Head, Tail > > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> (Loki::Private)
Append< Typelist< Head, Tail >, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const > (Loki::Private)
ArrayStorage (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) const volatile > (Loki::Private)
AssertCheck (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11) volatile > (Loki::Private)
AssertCheckStrict (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> (Loki::Private)
AssocVector (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const > (Loki::Private)
AssocVector::value_compare (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) const volatile > (Loki::Private)
AssocVectorCompare (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12) volatile > (Loki::Private)
B
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> (Loki::Private)
BaseVisitable< R, CatchAll, false > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const > (Loki::Private)
BaseVisitable< R, CatchAll, true > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) const volatile > (Loki::Private)
BaseVisitor (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13) volatile > (Loki::Private)
BaseVisitorImpl< Typelist< Head, NullType >, R > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> (Loki::Private)
BaseVisitorImpl< Typelist< Head, Tail >, R > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const > (Loki::Private)
BasicDispatcher (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) const volatile > (Loki::Private)
BinderFirst (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14) volatile > (Loki::Private)
BinderFirstBoundTypeStorage (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> (Loki::Private)
BinderFirstBoundTypeStorage< Functor< R, TList, ThreadingModel > > (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const > (Loki::Private)
BinderFirstTraits< Functor< R, TList, ThreadingModel > > (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) const volatile > (Loki::Private)
C
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15) volatile > (Loki::Private)
CachedFactory (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> (Loki::Private)
CacheException (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const > (Loki::Private)
CantResetWithStrong (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) const volatile > (Loki::Private)
Chainer (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16) volatile > (Loki::Private)
Chunk (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> (Loki::Private)
CloneFactory (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const > (Loki::Private)
CompileTimeError< true > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) const volatile > (Loki::Private)
COMRefCounted (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17) volatile > (Loki::Private)
ConcreteFactory (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> (Loki::Private)
ConcreteLifetimeTracker (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const > (Loki::Private)
ConstPropPtr (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) const volatile > (Loki::Private)
Conversion (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18) volatile > (Loki::Private)
Conversion< T, T > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> (Loki::Private)
Conversion< T, void > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const > (Loki::Private)
Conversion< void, T > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) const volatile > (Loki::Private)
Conversion< void, void > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) volatile > (Loki::Private)
ConversionHelper (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> (Loki::Private)
ConversionHelper::Big (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const > (Loki::Private)
CreateStatic (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) const volatile > (Loki::Private)
CreateStatic::MaxAlign (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) volatile > (Loki::Private)
CreateUsing (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> (Loki::Private)
CreateUsing::Allocator (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const > (Loki::Private)
CreateUsingMalloc (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) const volatile > (Loki::Private)
CreateUsingNew (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...) volatile > (Loki::Private)
CyclicVisitor (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> (Loki::Private)
D
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const > (Loki::Private)
DeepCopy (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) const volatile > (Loki::Private)
DefaultCatchAll (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...) volatile > (Loki::Private)
DefaultFactoryError (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> (Loki::Private)
DefaultFactoryError::Exception (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const > (Loki::Private)
DefaultLifetime (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) const volatile > (Loki::Private)
DefaultSPStorage (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...) volatile > (Loki::Private)
DeletableSingleton (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> (Loki::Private)
DeleteArray (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const > (Loki::Private)
DeleteNothing (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) const volatile > (Loki::Private)
Deleter (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...) volatile > (Loki::Private)
DeleteSingle (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> (Loki::Private)
DeleteUsingFree (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const > (Loki::Private)
DerivedToFront< NullType > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) const volatile > (Loki::Private)
DerivedToFront< Typelist< Head, Tail > > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...) volatile > (Loki::Private)
DestructiveCopy (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> (Loki::Private)
DieAsSmallObjectChild (Loki::LongevityLifetime) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const > (Loki::Private)
DieAsSmallObjectParent (Loki::LongevityLifetime) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) const volatile > (Loki::Private)
DieDirectlyBeforeLast (Loki::LongevityLifetime) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...) volatile > (Loki::Private)
DieFirst (Loki::LongevityLifetime) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> (Loki::Private)
DieLast (Loki::LongevityLifetime) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const > (Loki::Private)
DisallowConversion (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) const volatile > (Loki::Private)
DontPropagateConst (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...) volatile > (Loki::Private)
DynamicCaster (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> (Loki::Private)
E
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const > (Loki::Private)
EmptyType (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) const volatile > (Loki::Private)
Erase< NullType, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...) volatile > (Loki::Private)
Erase< Typelist< Head, Tail >, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> (Loki::Private)
Erase< Typelist< T, Tail >, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const > (Loki::Private)
EraseAll< NullType, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) const volatile > (Loki::Private)
EraseAll< Typelist< Head, Tail >, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...) volatile > (Loki::Private)
EraseAll< Typelist< T, Tail >, T > (Loki::TL) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> (Loki::Private)
EvictAging (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const > (Loki::Private)
EvictionException (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) const volatile > (Loki::Private)
EvictionHelper (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...) volatile > (Loki::Private)
EvictLRU (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> (Loki::Private)
EvictRandom (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const > (Loki::Private)
F
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) const volatile > (Loki::Private)
Factory (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...) volatile > (Loki::Private)
FactoryImpl< AP, Id, NullType > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> (Loki::Private)
FactoryImpl< AP, Id, Seq< P1 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) const volatile > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...) volatile > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) const volatile > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...) volatile > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) const volatile > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...) volatile > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06, P07,...)> (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) const volatile > (Loki::Private)
FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...) volatile > (Loki::Private)
FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05, P06,...)> (Loki::Private)
FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const > (Loki::Private)
FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) const volatile > (Loki::Private)
FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...) volatile > (Loki::Private)
FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05,...)> (Loki::Private)
FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const > (Loki::Private)
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 > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) const volatile > (Loki::Private)
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 > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...) volatile > (Loki::Private)
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 > > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04,...)> (Loki::Private)
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 > > > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const > (Loki::Private)
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 > > > > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) const volatile > (Loki::Private)
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 > > > > > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...) volatile > (Loki::Private)
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 > > > > > > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03,...)> (Loki::Private)
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 > > > > > > > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const > (Loki::Private)
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 > > > > > > > > > > > > > > >> (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) const volatile > (Loki::Private)
FactoryImplBase (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...) volatile > (Loki::Private)
FieldHelper (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01, P02,...)> (Loki::Private)
FieldHelper< H, 0 > (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01,...) const > (Loki::Private)
FixedAllocator (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01,...) const volatile > (Loki::Private)
FnDispatcher (Loki) IsMemberFunctionPointerRaw< T(S::*)(P01,...) volatile > (Loki::Private)
FnDispatcherHelper (Loki::Private) IsMemberFunctionPointerRaw< T(S::*)(P01,...)> (Loki::Private)
FollowIntoDeath (Loki) IsSameType (Loki)
FollowIntoDeath::AfterMaster (Loki) IsSameType< T, T > (Loki)
FollowIntoDeath::AfterMaster::IsDestroyed (Loki) IterateTypes (Loki::TL)
FollowIntoDeath::With (Loki) IterateTypes< NullType, GenFunc > (Loki::TL)
FollowIntoDeath::With::AsMasterLifetime (Loki) IterateTypes< Typelist< T1, T2 >, GenFunc > (Loki::TL)
Function
K
Function< R()> (Loki) Key (Loki)
Function< R(P01)> (Loki)
L
Function< R(P01, P02)> (Loki) Length< NullType > (Loki::TL)
Function< R(P01, P02, P03)> (Loki) Length< Typelist< T, U > > (Loki::TL)
Function< R(P01, P02, P03, P04)> (Loki) less< Loki::SmartPtr< T, OP, CP, KP, SP, CNP > > (std)
Function< R(P01, P02, P03, P04, P05)> (Loki) less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > (std)
Function< R(P01, P02, P03, P04, P05, P06)> (Loki) LifetimeTracker (Loki::Private)
Function< R(P01, P02, P03, P04, P05, P06, P07)> (Loki) LockableTwoRefCountInfo
Function< R(P01, P02, P03, P04, P05, P06, P07, P08)> (Loki) LockableTwoRefCounts
Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)> (Loki) LockedStorage (Loki)
Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> (Loki) Locker (Loki)
Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> (Loki) LockingPtr (Loki)
Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> (Loki)
M
Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> (Loki) MakeTypelist (Loki::TL)
Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> (Loki) MakeTypelist<> (Loki::TL)
Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> (Loki) MemFunHandler (Loki)
Function<> (Loki) MostDerived< NullType, T > (Loki::TL)
FunctionStorage (Loki) MostDerived< Typelist< Head, Tail >, T > (Loki::TL)
Functor (Loki) Mutex (Loki)
FunctorDispatcher (Loki)
N
FunctorDispatcherHelper (Loki::Private) nameof_type (Loki::TL)
FunctorHandler (Loki) NeverCreate (Loki)
FunctorImpl< R, NullType, ThreadingModel > (Loki) NeverCreate::Exception (Loki)
FunctorImpl< R, Seq< P1 >, ThreadingModel > (Loki) NeverReset (Loki)
FunctorImpl< R, Seq< P1, P2 >, ThreadingModel > (Loki) NoCheck (Loki)
FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel > (Loki) NoCopy (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel > (Loki) NoDestroy (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel > (Loki) NoDuplicates< NullType > (Loki::TL)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel > (Loki) NoDuplicates< Typelist< Head, Tail > > (Loki::TL)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel > (Loki) NoStatisticPolicy (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel > (Loki) NullPointerException (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel > (Loki) NullType (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel > (Loki)
O
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel > (Loki) ObjScopeGuardImpl0 (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel > (Loki) ObjScopeGuardImpl1 (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel > (Loki) ObjScopeGuardImpl2 (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel > (Loki) ObjScopeGuardImpl3 (Loki)
FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel > (Loki) OpNewFactoryUnit (Loki)
FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel > (Loki) OrderedStatic< L, T, Loki::NullType > (Loki)
FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel > (Loki) OrderedStatic< L, T, Loki::Seq< P1 > > (Loki)
FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel > (Loki) OrderedStatic< L, T, P1(*)() > (Loki)
FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel > (Loki) OrderedStaticBase (Loki::Private)
FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel > (Loki) OrderedStaticCreatorFunc (Loki::Private)
FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel > (Loki) OrderedStaticManagerClass (Loki::Private)
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 > (Loki)
P
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 > (Loki) PhoenixSingleton (Loki)
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 > (Loki) Pimpl (Loki)
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 > (Loki) PImplOf
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 > (Loki) PimplOf (Loki)
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 > (Loki) PimplOwner (Loki)
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 > (Loki) PrintfState (Loki)
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 > (Loki) PropagateConst (Loki)
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 > (Loki) PrototypeFactoryUnit (Loki)
FunctorImplBase (Loki::Private)
R
G
RateLimitedCreation (Loki)
GenLinearHierarchy< NullType, Unit, Root > (Loki) RateLimitedCreation::Exception (Loki)
GenLinearHierarchy< Typelist< T, NullType >, Unit, Root > (Loki) RefCounted (Loki)
GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root > (Loki) RefCountedMT
GenScatterHierarchy (Loki) RefCountedMTAdj (Loki)
GenScatterHierarchy< NullType, Unit > (Loki) RefCountedMTAdj::RefCountedMT (Loki)
GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit > (Loki) RefLinked (Loki)
GenScatterHierarchy< Typelist< T1, T2 >, Unit > (Loki) RefLinkedBase (Loki::Private)
GenScatterHierarchy< Typelist< T1, T2 >, Unit >::Rebind (Loki) RefToValue (Loki)
H
RegisterOnCreate (Loki::Private)
HeapStorage (Loki) RegisterOnCreateElement (Loki::Private)
I
RegisterOnCreateSet (Loki)
ImplOf RejectNull (Loki)
IndexOf< NullType, T > (Loki::TL) RejectNullStatic (Loki)
IndexOf< Typelist< Head, Tail >, T > (Loki::TL) RejectNullStrict (Loki)
IndexOf< Typelist< T, Tail >, T > (Loki::TL) Replace< NullType, T, U > (Loki::TL)
Int2Type (Loki) Replace< Typelist< Head, Tail >, T, U > (Loki::TL)
InvocationTraits (Loki::Private) Replace< Typelist< T, Tail >, T, U > (Loki::TL)
IsCustomFloat (Loki) ReplaceAll< NullType, T, U > (Loki::TL)
IsCustomSignedInt (Loki) ReplaceAll< Typelist< Head, Tail >, T, U > (Loki::TL)
IsCustomUnsignedInt (Loki) ReplaceAll< Typelist< T, Tail >, T, U > (Loki::TL)
IsFunctionPointerRaw (Loki::Private) Reverse< NullType > (Loki::TL)
IsFunctionPointerRaw< T(*)()> (Loki::Private) Reverse< Typelist< Head, Tail > > (Loki::TL)
IsFunctionPointerRaw< T(*)(...)> (Loki::Private) RimplOf (Loki)
IsFunctionPointerRaw< T(*)(P01)> (Loki::Private) RimplOf::Owner (Loki)
IsFunctionPointerRaw< T(*)(P01, P02)> (Loki::Private)
S
IsFunctionPointerRaw< T(*)(P01, P02, P03)> (Loki::Private) ScopeGuardImpl0 (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04)> (Loki::Private) ScopeGuardImpl1 (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05)> (Loki::Private) ScopeGuardImpl2 (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06)> (Loki::Private) ScopeGuardImpl3 (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07)> (Loki::Private) ScopeGuardImpl4 (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08)> (Loki::Private) ScopeGuardImpl5 (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09)> (Loki::Private) ScopeGuardImplBase (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)> (Loki::Private) Select (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)> (Loki::Private) Select< false, T, U > (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)> (Loki::Private) Seq (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)> (Loki::Private) Seq<> (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)> (Loki::Private) SimplePointer (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)> (Loki::Private) SimpleStatisticPolicy (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16)> (Loki::Private) SingleThreaded (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17)> (Loki::Private) SingleThreaded::Lock (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18)> (Loki::Private) Singleton (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)> (Loki::Private) SingletonFixedLongevity (Loki::LongevityLifetime)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)> (Loki::Private) SingletonHolder (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20,...)> (Loki::Private) SingletonWithLongevity (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19,...)> (Loki::Private) sizeof_type (Loki::TL)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17, P18,...)> (Loki::Private) SmallObjAllocator (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16, P17,...)> (Loki::Private) SmallObject (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15, P16,...)> (Loki::Private) SmallObjectBase (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15,...)> (Loki::Private) SmallValueObject (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14,...)> (Loki::Private) SmartPointer (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13,...)> (Loki::Private) SmartPtr (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12,...)> (Loki::Private) SmartPtrDef (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11,...)> (Loki::Private) StaticCaster (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10,...)> (Loki::Private) StaticDispatcher (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08, P09,...)> (Loki::Private) StrongPtr (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07, P08,...)> (Loki::Private) SuperSubclass (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06, P07,...)> (Loki::Private) SuperSubclass< T, void > (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05, P06,...)> (Loki::Private) SuperSubclass< void, U > (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04, P05,...)> (Loki::Private) SuperSubclass< void, void > (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03, P04,...)> (Loki::Private) SuperSubclassStrict (Loki)
IsFunctionPointerRaw< T(*)(P01, P02, P03,...)> (Loki::Private) SuperSubclassStrict< T, void > (Loki)
IsFunctionPointerRaw< T(*)(P01, P02,...)> (Loki::Private) SuperSubclassStrict< void, U > (Loki)
IsFunctionPointerRaw< T(*)(P01,...)> (Loki::Private) SuperSubclassStrict< void, void > (Loki)
IsMemberFunctionPointerRaw (Loki::Private)
T
IsMemberFunctionPointerRaw< T(S::*)() const > (Loki::Private) Tuple (Loki)
IsMemberFunctionPointerRaw< T(S::*)() const volatile > (Loki::Private) TupleUnit (Loki)
IsMemberFunctionPointerRaw< T(S::*)() volatile > (Loki::Private) TwoRefCountInfo (Loki::Private)
IsMemberFunctionPointerRaw< T(S::*)()> (Loki::Private) TwoRefCounts (Loki)
IsMemberFunctionPointerRaw< T(S::*)(...) const > (Loki::Private) TwoRefLinks (Loki)
IsMemberFunctionPointerRaw< T(S::*)(...) const volatile > (Loki::Private) Type2Type (Loki)
IsMemberFunctionPointerRaw< T(S::*)(...) volatile > (Loki::Private) TypeAt< Typelist< Head, Tail >, 0 > (Loki::TL)
IsMemberFunctionPointerRaw< T(S::*)(...)> (Loki::Private) TypeAt< Typelist< Head, Tail >, i > (Loki::TL)
IsMemberFunctionPointerRaw< T(S::*)(P01) const > (Loki::Private) TypeAtNonStrict (Loki::TL)
IsMemberFunctionPointerRaw< T(S::*)(P01) const volatile > (Loki::Private) TypeAtNonStrict< Typelist< Head, Tail >, 0, DefaultType > (Loki::TL)
IsMemberFunctionPointerRaw< T(S::*)(P01) volatile > (Loki::Private) TypeAtNonStrict< Typelist< Head, Tail >, i, DefaultType > (Loki::TL)
IsMemberFunctionPointerRaw< T(S::*)(P01)> (Loki::Private) TypeInfo (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const > (Loki::Private) Typelist (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02) const volatile > (Loki::Private) TypeTraits (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02) volatile > (Loki::Private)
U
IsMemberFunctionPointerRaw< T(S::*)(P01, P02)> (Loki::Private) UnRegisterOnDelete (Loki::Private)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const > (Loki::Private) UnRegisterOnDeleteElement (Loki::Private)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) const volatile > (Loki::Private) UnRegisterOnDeleteSet (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03) volatile > (Loki::Private)
V
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03)> (Loki::Private) Visitor
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const > (Loki::Private) Visitor< T, R, false > (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) const volatile > (Loki::Private) Visitor< T, R, true > (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04) volatile > (Loki::Private) Visitor< Typelist< Head, NullType >, R, false > (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04)> (Loki::Private) Visitor< Typelist< Head, NullType >, R, true > (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const > (Loki::Private) Visitor< Typelist< Head, Tail >, R, false > (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) const volatile > (Loki::Private) Visitor< Typelist< Head, Tail >, R, true > (Loki)
IsMemberFunctionPointerRaw< T(S::*)(P01, P02, P03, P04, P05) volatile > (Loki::Private)

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

Generated on Sat Jul 7 15:11:09 2007 for Loki by doxygen 1.5.1-p1


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;
};
If the MAX_DOT_GRAPH_HEIGHT tag in the configuration file is set to 240 this will result in the following graph:

The boxes in the above graph have the following meaning:

  • A filled black box represents the struct or class for which the graph is generated.
  • A box with a black border denotes a documented struct or class.
  • A box with a grey border denotes an undocumented struct or class.
  • A box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries.
The arrows have the following meaning:
  • A dark blue arrow is used to visualize a public inheritance relation between two classes.
  • A dark green arrow is used for protected inheritance.
  • A dark red arrow is used for private inheritance.
  • A purple dashed arrow is used if a class is contained or used by another class. The arrow is labeled with the variable(s) through which the pointed class or struct is accessible.
  • A yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labeled with the template parameters of the instance.
Generated on Sat Jul 7 15:12:47 2007 for Loki by doxygen 1.5.1-p1


Loki: Main Page

Loki Documentation

0.1.6

Generated on Sat Jul 7 15:10:59 2007 for Loki by doxygen 1.5.1-p1