Detailed Description

general utility, debug facilities, ...

The util namespace contains general utilities, debug facilities, etc. used by our lass software. The following stuff is provided:

Allocator: library of custom allocator building blocks
Atomic: atomic operations on integers
Bind: bind function and arguments to nullary callback
BitManip: a set of bit manipulation routines
Callback: library to wrap callback functions in first class objects.
CallTraits: defines best types for arguments, references, etc.
Clock: an class to measure time.
CloneFactory: implements Alexandrescu's clone factory pattern.
CommonMacros: a set of common macros for your convenience
Dictionary: a bidirectional dictonary wrapper around a std::map.
empty.h: an empty header for those moments you want to include absolutely nothing.
Enforcers: release-time counterpart of assertions to ease condition verifying
Environment: accessing environment variables
Exception: the exception class used by LASS
IdGenerator: Generates unique ID's of the type you want (well, not all types).
NonCopyable: boost::non_copyable
ObjectFactory: implements Alexandrescu's object factory.
Process: concerning process settings.
ProgressIndicator: a class to print a progress message.
Python: Python binding library
Singleton: implements the singleton idiom in a non-intrusive way, very easy.
SmallObject: base class for small objects that need a specialized allocator.
SmartPtr: library of configurable smart pointers like ScopedPtr and SharedPtr
stringCast: casts a value to a type by using string streams, to cast to/from strings.
Threading: basic multithreading library
ThreadFun: Uses the Bind library to run existing functions in threads
ThreadPool: producer/consumer pattern with multithreading ...
VisitorPattern: implements Alexandrescu's visitor pattern.

Data Structures
class	AllocatorAligned

class	AllocatorAlignedAlloc

class	AllocatorClassAdaptor
	Use an Allocator to implement a class' new and delete. More...

class	AllocatorConcurrentFreeList
	A fixed-size lock-free free-list allocator. More...

class	AllocatorFixed
	fixes a variable-size allocator to one size. More...

class	AllocatorFreeList
	A fixed-size free-list allocator. More...

class	AllocatorLocked
	Guard a MT unsafe allocator with some lock. More...

class	AllocatorMalloc

class	AllocatorNoThrow

class	AllocatorPerThread
	Instantiates an Allocator per thread. More...

class	AllocatorSimpleBlock
	A simple fixed-size block allocator. More...

class	AllocatorSingleton

class	AllocatorSized

class	AllocatorStaticFixed

class	AllocatorStats

class	AllocatorThrow

class	AllocatorVariable
	A variable-size allocator built on top of a fixed-size allocator. More...

class	ArrayStorage
	Default storage policy for arrays, implementation of StoragePolicy concept. More...

class	Callback0
	callback with 0 parameter(s) and without returnvalue. More...

class	Callback1
	callback with 1 parameter(s) but without returnvalue. More...

class	Callback10
	callback with 10 parameter(s) but without returnvalue. More...

class	Callback11
	callback with 11 parameter(s) but without returnvalue. More...

class	Callback12
	callback with 12 parameter(s) but without returnvalue. More...

class	Callback13
	callback with 13 parameter(s) but without returnvalue. More...

class	Callback14
	callback with 14 parameter(s) but without returnvalue. More...

class	Callback15
	callback with 15 parameter(s) but without returnvalue. More...

class	Callback2
	callback with 2 parameter(s) but without returnvalue. More...

class	Callback3
	callback with 3 parameter(s) but without returnvalue. More...

class	Callback4
	callback with 4 parameter(s) but without returnvalue. More...

class	Callback5
	callback with 5 parameter(s) but without returnvalue. More...

class	Callback6
	callback with 6 parameter(s) but without returnvalue. More...

class	Callback7
	callback with 7 parameter(s) but without returnvalue. More...

class	Callback8
	callback with 8 parameter(s) but without returnvalue. More...

class	Callback9
	callback with 9 parameter(s) but without returnvalue. More...

class	CallbackR0
	callback with 0 parameters but with returnvalue. More...

class	CallbackR1
	callback with 1 parameter1 and with returnvalue. More...

class	CallbackR10
	callback with 10 parameter10 and with returnvalue. More...

class	CallbackR11
	callback with 11 parameter11 and with returnvalue. More...

class	CallbackR12
	callback with 12 parameter12 and with returnvalue. More...

class	CallbackR13
	callback with 13 parameter13 and with returnvalue. More...

class	CallbackR14
	callback with 14 parameter14 and with returnvalue. More...

class	CallbackR15
	callback with 15 parameter15 and with returnvalue. More...

class	CallbackR2
	callback with 2 parameter2 and with returnvalue. More...

class	CallbackR3
	callback with 3 parameter3 and with returnvalue. More...

class	CallbackR4
	callback with 4 parameter4 and with returnvalue. More...

class	CallbackR5
	callback with 5 parameter5 and with returnvalue. More...

class	CallbackR6
	callback with 6 parameter6 and with returnvalue. More...

class	CallbackR7
	callback with 7 parameter7 and with returnvalue. More...

class	CallbackR8
	callback with 8 parameter8 and with returnvalue. More...

class	CallbackR9
	callback with 9 parameter9 and with returnvalue. More...

class	CloneFactory
	object creation by cloning prototypes More...

class	Condition
	Condition. More...

class	CriticalSection
	CriticalSection. More...

class	DefaultConsumer
	Default consumer calls operator() of task. More...

class	DefaultCounter
	The default counter for the shared pointers, implementation of CounterPolicy concept. More...

class	Dictionary
	a wrapper around a std::map to translate keys in values and back. More...

class	EnforceFailure
	Exception thrown by enforcers. More...

class	Exception
	type of all exceptions in lass More...

struct	FixedArray
	compile time fixed array that also supports zero length More...

class	IdGenerator
	Generates sequential and unique ID's. More...

class	IntrusiveCounter
	implementation of CounterPolicy concept, using a counter in the managed object itself. More...

class	LockerBase
	Common base class for lockers. More...

class	Mutex
	Mutex. More...

class	NonCopyable
	use as base class if derived should not be copyable More...

class	NotParticipating
	implementation of ThreadPool's ParticipationPolicy More...

class	ObjectStorage
	Default storage policy for single objects, implementation of StoragePolicy concept. More...

class	ProgressIndicator
	Prints a progress indication to console. More...

class	RWLock
	Lean and mean synchronisation object, without OS support. More...

class	SelfParticipating
	implementation of ThreadPool's ParticipationPolicy More...

class	Semaphore
	Lean and mean synchronisation object, without OS support. More...

class	Signaled
	implementation of ThreadPool's IdlePolicy More...

class	Singleton
	non-intrusive singleton holder. More...

class	SmartI
	smart pointer to COM interfaces More...

class	Spinning
	implementation of ThreadPool's IdlePolicy More...

class	TaggedPtr
	Pointer with a tag for ABA salvationSome lock-free algorithms suffer from the ABA problem when acting on pointers. More...

class	Thread
	A base class for threads. More...

class	ThreadLocalStorage
	A primitive to provide Thread Local Storage functionality. More...

class	ThreadLocalVariable
	A primitive to provide Thread Local Storage functionality for a first-citizen class. More...

Typedefs
typedef util::Dictionary< std::string, ProcessPriority >	TProcessPriorityDictionary
	type of dictionary that can translate strings to ProcessPriority values.

typedef Locker< Mutex >	MutexLocker
	typedef of Locker for Mutex

typedef Locker< CriticalSection >	CriticalSectionLocker
	typedef of Locker for CriticalSection

typedef Locker< Semaphore >	SemaphoreLocker
	typedef of Locker for Semaphore

Enumerations
enum	ProcessPriority
	different process priority levels

enum	DestructionPriorities
	Destruction priority constants. More...

enum	LockResult { lockSuccess , lockBusy }
	Return code for lock functions. More...

enum	WaitResult { waitSuccess , waitTimeout }
	Return code for wait functions. More...

enum	ThreadKind { threadDetached , threadJoinable }
	ThreadKind. More...

Functions
template<typename T>
bool	atomicCompareAndSwap (volatile T &dest, T expectedValue, T newValue)
	Performs the following pseudocode in an atomic way (no other threads can intervene):

template<typename T1, typename T2>
bool	atomicCompareAndSwap (volatile T1 &dest1, T1 expected1, T2 expected2, T1 new1, T2 new2)
	Performs the following pseudocode in an atomic way (no other threads can intervene):

template<typename T>
void	atomicIncrement (volatile T &value)
	Performs the following pseudocode in an atomic way (no other threads can intervene):

template<typename T>
void	atomicDecrement (volatile T &value)
	Performs the following pseudocode in an atomic way (no other threads can intervene):

template<typename T>
void	atomicLock (volatile T &semaphore)

template<typename T>
bool	atomicTryLock (volatile T &semaphore)

template<typename T>
void	atomicUnlock (volatile T &semaphore)

template<typename T>
void	setBit (T &a_bits, size_t a_bit)
	Set a bit high.

template<typename T>
void	clearBit (T &a_bits, size_t a_bit)
	set a bit low.

template<typename T>
void	flipBit (T &a_bits, size_t a_bit)
	flip state of a bit (low->high, high->low).

template<typename T>
void	setBitIf (T &a_bits, size_t a_bit, bool a_condition)
	set a bit high if (and only if) a condition is fullfilled.

template<typename T>
void	clearBitIf (T &a_bits, size_t a_bit, bool a_condition)
	set a bit low if (and only if) a condition is fullfilled is true.

template<typename T>
void	flipBitIf (T &a_bits, size_t a_bit, bool a_condition)
	flip a bit if (and only if) a condition is fullfilled (low->high, high->low).

template<typename T>
void	setBitTo (T &a_bits, size_t a_bit, bool a_state)
	set a bit to a given state.

template<typename T>
bool	checkBit (T a_bits, size_t a_bit)
	return true if a bit is set high.

template<typename T>
void	setMasked (T &a_bits, const T &a_mask)
	Set masked bits high.

template<typename T>
void	clearMasked (T &a_bits, const T &a_mask)
	Set masked bits low.

template<typename T>
void	flipMasked (T &a_bits, const T &a_mask)
	flip masked bits.

template<typename T>
void	setMaskedIf (T &a_bits, const T &a_mask, bool a_condition)
	Set masked bits high if (and only if) a condition is fullfilled.

template<typename T>
void	clearMaskedIf (T &a_bits, const T &a_mask, bool a_condition)
	Set masked bits low if (and only if) a condition is fullfilled.

template<typename T>
void	flipMaskedIf (T &a_bits, const T &a_mask, bool a_condition)
	Flip the masked bits if (and only if) a condition is fullfilled.

template<typename T>
void	setMaskedTo (T &a_bits, const T &a_mask, bool a_state)
	Set the masked bits to a given state if (and only if) a condition is fullfilled.

template<typename T>
bool	checkMaskedAll (T a_bits, const T &a_mask)
	Check the masked bits and return true if they are ALL set.

template<typename T>
bool	checkMaskedSome (T a_bits, const T &a_mask)
	Check the masked bits and return true if at least one is set.

template<typename T>
size_t	countBits (T bits)
	returns number of set bits in bits

const Callback0 &	makeCallback (const Callback0 &iCallback)
	convencie function, make callback from callback

void	setProcessPriority (const std::string &iPriority)
	set process priority by string

TProcessPriorityDictionary &	processPriorityDictionary ()
	singleton with dictionary that can translate strings to ProcessPriority.

LASS_DLL void LASS_CALL	setProcessPriority (ProcessPriority iPriority)
	set process priority by ProcessPriority value

size_t	numberOfProcessors ()
	Return highest id of processor + 1, in this machine.

size_t	numberOfAvailableProcessors ()
	Return total number of processors in machine that are online.

bool	isAvailableProcessor (size_t processor)
	Check whether a processor is avaialable.

bool	operator!= (const Callback0 &iA, const Callback0 &iB)
	return true if two callbacks are different

Callback0	makeCallback (void(*iFunction)())
	make a Callback0 from a function

template<typename ObjectPtr, typename Object>
Callback0	makeCallback (ObjectPtr iObject, void(Object::*iMethod)())
	make a Callback0 from a object and method

template<typename ObjectPtr, typename Object>
Callback0	makeCallback (ObjectPtr iObject, void(Object::*iMethod)() const)
	make a Callback0 from a object and const method

template<typename P1>
bool	operator!= (const Callback1< P1 > &iA, const Callback1< P1 > &iB)
	return true if two callbacks are different

template<typename P1>
Callback1< P1 >	makeCallback (void(*iFunction)(P1))
	make a Callback1 from a function

template<typename P1>
const Callback1< P1 > &	makeCallback (const Callback1< P1 > &iCallback)
	make a Callback1 from a callback

template<typename ObjectPtr, typename Object, typename P1>
Callback1< P1 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1))
	make a Callback1 from a object and method

template<typename ObjectPtr, typename Object, typename P1>
Callback1< P1 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1) const)
	make a Callback1 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
bool	operator!= (const Callback10< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &iA, const Callback10< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
Callback10< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10))
	make a Callback10 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
const Callback10< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &	makeCallback (const Callback10< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &iCallback)
	make a Callback10 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
Callback10< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10))
	make a Callback10 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
Callback10< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const)
	make a Callback10 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
bool	operator!= (const Callback11< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &iA, const Callback11< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
Callback11< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11))
	make a Callback11 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
const Callback11< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &	makeCallback (const Callback11< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &iCallback)
	make a Callback11 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
Callback11< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11))
	make a Callback11 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
Callback11< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const)
	make a Callback11 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
bool	operator!= (const Callback12< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &iA, const Callback12< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
Callback12< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12))
	make a Callback12 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
const Callback12< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &	makeCallback (const Callback12< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &iCallback)
	make a Callback12 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
Callback12< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12))
	make a Callback12 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
Callback12< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const)
	make a Callback12 from a object and const method

template<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>
bool	operator!= (const Callback13< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &iA, const Callback13< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &iB)
	return true if two callbacks are different

template<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>
Callback13< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13))
	make a Callback13 from a function

template<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>
const Callback13< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &	makeCallback (const Callback13< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &iCallback)
	make a Callback13 from a callback

template<typename ObjectPtr, typename Object, 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>
Callback13< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13))
	make a Callback13 from a object and method

template<typename ObjectPtr, typename Object, 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>
Callback13< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const)
	make a Callback13 from a object and const method

template<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>
bool	operator!= (const Callback14< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &iA, const Callback14< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &iB)
	return true if two callbacks are different

template<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>
Callback14< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14))
	make a Callback14 from a function

template<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>
const Callback14< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &	makeCallback (const Callback14< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &iCallback)
	make a Callback14 from a callback

template<typename ObjectPtr, typename Object, 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>
Callback14< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14))
	make a Callback14 from a object and method

template<typename ObjectPtr, typename Object, 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>
Callback14< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const)
	make a Callback14 from a object and const method

template<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>
bool	operator!= (const Callback15< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &iA, const Callback15< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &iB)
	return true if two callbacks are different

template<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>
Callback15< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15))
	make a Callback15 from a function

template<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>
const Callback15< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &	makeCallback (const Callback15< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &iCallback)
	make a Callback15 from a callback

template<typename ObjectPtr, typename Object, 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>
Callback15< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15))
	make a Callback15 from a object and method

template<typename ObjectPtr, typename Object, 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>
Callback15< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const)
	make a Callback15 from a object and const method

template<typename P1, typename P2>
bool	operator!= (const Callback2< P1, P2 > &iA, const Callback2< P1, P2 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2>
Callback2< P1, P2 >	makeCallback (void(*iFunction)(P1, P2))
	make a Callback2 from a function

template<typename P1, typename P2>
const Callback2< P1, P2 > &	makeCallback (const Callback2< P1, P2 > &iCallback)
	make a Callback2 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2>
Callback2< P1, P2 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2))
	make a Callback2 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2>
Callback2< P1, P2 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2) const)
	make a Callback2 from a object and const method

template<typename P1, typename P2, typename P3>
bool	operator!= (const Callback3< P1, P2, P3 > &iA, const Callback3< P1, P2, P3 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3>
Callback3< P1, P2, P3 >	makeCallback (void(*iFunction)(P1, P2, P3))
	make a Callback3 from a function

template<typename P1, typename P2, typename P3>
const Callback3< P1, P2, P3 > &	makeCallback (const Callback3< P1, P2, P3 > &iCallback)
	make a Callback3 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3>
Callback3< P1, P2, P3 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3))
	make a Callback3 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3>
Callback3< P1, P2, P3 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3) const)
	make a Callback3 from a object and const method

template<typename P1, typename P2, typename P3, typename P4>
bool	operator!= (const Callback4< P1, P2, P3, P4 > &iA, const Callback4< P1, P2, P3, P4 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4>
Callback4< P1, P2, P3, P4 >	makeCallback (void(*iFunction)(P1, P2, P3, P4))
	make a Callback4 from a function

template<typename P1, typename P2, typename P3, typename P4>
const Callback4< P1, P2, P3, P4 > &	makeCallback (const Callback4< P1, P2, P3, P4 > &iCallback)
	make a Callback4 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4>
Callback4< P1, P2, P3, P4 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4))
	make a Callback4 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4>
Callback4< P1, P2, P3, P4 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4) const)
	make a Callback4 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5>
bool	operator!= (const Callback5< P1, P2, P3, P4, P5 > &iA, const Callback5< P1, P2, P3, P4, P5 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5>
Callback5< P1, P2, P3, P4, P5 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5))
	make a Callback5 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5>
const Callback5< P1, P2, P3, P4, P5 > &	makeCallback (const Callback5< P1, P2, P3, P4, P5 > &iCallback)
	make a Callback5 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5>
Callback5< P1, P2, P3, P4, P5 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5))
	make a Callback5 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5>
Callback5< P1, P2, P3, P4, P5 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5) const)
	make a Callback5 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
bool	operator!= (const Callback6< P1, P2, P3, P4, P5, P6 > &iA, const Callback6< P1, P2, P3, P4, P5, P6 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Callback6< P1, P2, P3, P4, P5, P6 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6))
	make a Callback6 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
const Callback6< P1, P2, P3, P4, P5, P6 > &	makeCallback (const Callback6< P1, P2, P3, P4, P5, P6 > &iCallback)
	make a Callback6 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Callback6< P1, P2, P3, P4, P5, P6 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6))
	make a Callback6 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Callback6< P1, P2, P3, P4, P5, P6 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6) const)
	make a Callback6 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
bool	operator!= (const Callback7< P1, P2, P3, P4, P5, P6, P7 > &iA, const Callback7< P1, P2, P3, P4, P5, P6, P7 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
Callback7< P1, P2, P3, P4, P5, P6, P7 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7))
	make a Callback7 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
const Callback7< P1, P2, P3, P4, P5, P6, P7 > &	makeCallback (const Callback7< P1, P2, P3, P4, P5, P6, P7 > &iCallback)
	make a Callback7 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
Callback7< P1, P2, P3, P4, P5, P6, P7 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7))
	make a Callback7 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
Callback7< P1, P2, P3, P4, P5, P6, P7 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7) const)
	make a Callback7 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
bool	operator!= (const Callback8< P1, P2, P3, P4, P5, P6, P7, P8 > &iA, const Callback8< P1, P2, P3, P4, P5, P6, P7, P8 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
Callback8< P1, P2, P3, P4, P5, P6, P7, P8 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8))
	make a Callback8 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
const Callback8< P1, P2, P3, P4, P5, P6, P7, P8 > &	makeCallback (const Callback8< P1, P2, P3, P4, P5, P6, P7, P8 > &iCallback)
	make a Callback8 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
Callback8< P1, P2, P3, P4, P5, P6, P7, P8 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8))
	make a Callback8 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
Callback8< P1, P2, P3, P4, P5, P6, P7, P8 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8) const)
	make a Callback8 from a object and const method

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
bool	operator!= (const Callback9< P1, P2, P3, P4, P5, P6, P7, P8, P9 > &iA, const Callback9< P1, P2, P3, P4, P5, P6, P7, P8, P9 > &iB)
	return true if two callbacks are different

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
Callback9< P1, P2, P3, P4, P5, P6, P7, P8, P9 >	makeCallback (void(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9))
	make a Callback9 from a function

template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
const Callback9< P1, P2, P3, P4, P5, P6, P7, P8, P9 > &	makeCallback (const Callback9< P1, P2, P3, P4, P5, P6, P7, P8, P9 > &iCallback)
	make a Callback9 from a callback

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
Callback9< P1, P2, P3, P4, P5, P6, P7, P8, P9 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9))
	make a Callback9 from a object and method

template<typename ObjectPtr, typename Object, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
Callback9< P1, P2, P3, P4, P5, P6, P7, P8, P9 >	makeCallback (ObjectPtr iObject, void(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const)
	make a Callback9 from a object and const method

template<typename R>
bool	operator!= (const CallbackR0< R > &iA, const CallbackR0< R > &iB)
	return true if two callbacks are different

template<typename R>
CallbackR0< R >	makeCallback (R(*iFunction)())
	make a CallbackR0 from a function

template<typename R>
const CallbackR0< R > &	makeCallback (const CallbackR0< R > &iCallback)
	make a CallbackR0 from a callback

template<typename ObjectPtr, typename Object, typename R>
CallbackR0< R >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)())
	make a CallbackR0 from a object and method

template<typename ObjectPtr, typename Object, typename R>
CallbackR0< R >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)() const)
	make a CallbackR0 from a object and const method

template<typename R, typename P1>
bool	operator!= (const CallbackR1< R, P1 > &iA, const CallbackR1< R, P1 > &iB)
	return true if two callbacks are different

template<typename R, typename P1>
CallbackR1< R, P1 >	makeCallback (R(*iFunction)(P1))
	make a CallbackR1 from a function

template<typename R, typename P1>
const CallbackR1< R, P1 > &	makeCallback (const CallbackR1< R, P1 > &iCallback)
	make a CallbackR1 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1>
CallbackR1< R, P1 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1))
	make a CallbackR1 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1>
CallbackR1< R, P1 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1) const)
	make a CallbackR1 from a object and const method

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
bool	operator!= (const CallbackR10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &iA, const CallbackR10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
CallbackR10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10))
	make a CallbackR10 from a function

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
const CallbackR10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &	makeCallback (const CallbackR10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > &iCallback)
	make a CallbackR10 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
CallbackR10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10))
	make a CallbackR10 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
CallbackR10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const)
	make a CallbackR10 from a object and const method

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>
bool	operator!= (const CallbackR11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &iA, const CallbackR11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &iB)
	return true if two callbacks are different

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>
CallbackR11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11))
	make a CallbackR11 from a function

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>
const CallbackR11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &	makeCallback (const CallbackR11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > &iCallback)
	make a CallbackR11 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
CallbackR11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11))
	make a CallbackR11 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
CallbackR11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const)
	make a CallbackR11 from a object and const method

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>
bool	operator!= (const CallbackR12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &iA, const CallbackR12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &iB)
	return true if two callbacks are different

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>
CallbackR12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12))
	make a CallbackR12 from a function

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>
const CallbackR12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &	makeCallback (const CallbackR12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > &iCallback)
	make a CallbackR12 from a function

template<typename ObjectPtr, typename Object, 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>
CallbackR12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12))
	make a CallbackR12 from a object and method

template<typename ObjectPtr, typename Object, 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>
CallbackR12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const)
	make a CallbackR12 from a object and const method

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>
bool	operator!= (const CallbackR13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &iA, const CallbackR13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &iB)
	return true if two callbacks are different

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>
CallbackR13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13))
	make a CallbackR13 from a function

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>
const CallbackR13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &	makeCallback (const CallbackR13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > &iCallback)
	make a CallbackR13 from a function

template<typename ObjectPtr, typename Object, 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>
CallbackR13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13))
	make a CallbackR13 from a object and method

template<typename ObjectPtr, typename Object, 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>
CallbackR13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const)
	make a CallbackR13 from a object and const method

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>
bool	operator!= (const CallbackR14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &iA, const CallbackR14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &iB)
	return true if two callbacks are different

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>
CallbackR14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14))
	make a CallbackR14 from a function

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>
const CallbackR14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &	makeCallback (const CallbackR14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > &iCallback)
	make a CallbackR14 from a function

template<typename ObjectPtr, typename Object, 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>
CallbackR14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14))
	make a CallbackR14 from a object and method

template<typename ObjectPtr, typename Object, 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>
CallbackR14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const)
	make a CallbackR14 from a object and const method

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>
bool	operator!= (const CallbackR15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &iA, const CallbackR15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &iB)
	return true if two callbacks are different

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>
CallbackR15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15))
	make a CallbackR15 from a function

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>
const CallbackR15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &	makeCallback (const CallbackR15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > &iCallback)
	make a CallbackR15 from a function

template<typename ObjectPtr, typename Object, 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>
CallbackR15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15))
	make a CallbackR15 from a object and method

template<typename ObjectPtr, typename Object, 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>
CallbackR15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const)
	make a CallbackR15 from a object and const method

template<typename R, typename P1, typename P2>
bool	operator!= (const CallbackR2< R, P1, P2 > &iA, const CallbackR2< R, P1, P2 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2>
CallbackR2< R, P1, P2 >	makeCallback (R(*iFunction)(P1, P2))
	make a CallbackR2 from a function

template<typename R, typename P1, typename P2>
const CallbackR2< R, P1, P2 > &	makeCallback (const CallbackR2< R, P1, P2 > &iCallback)
	make a CallbackR2 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2>
CallbackR2< R, P1, P2 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2))
	make a CallbackR2 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2>
CallbackR2< R, P1, P2 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2) const)
	make a CallbackR2 from a object and const method

template<typename R, typename P1, typename P2, typename P3>
bool	operator!= (const CallbackR3< R, P1, P2, P3 > &iA, const CallbackR3< R, P1, P2, P3 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3>
CallbackR3< R, P1, P2, P3 >	makeCallback (R(*iFunction)(P1, P2, P3))
	make a CallbackR3 from a function

template<typename R, typename P1, typename P2, typename P3>
const CallbackR3< R, P1, P2, P3 > &	makeCallback (const CallbackR3< R, P1, P2, P3 > &iCallback)
	make a CallbackR3 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3>
CallbackR3< R, P1, P2, P3 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3))
	make a CallbackR3 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3>
CallbackR3< R, P1, P2, P3 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3) const)
	make a CallbackR3 from a object and const method

template<typename R, typename P1, typename P2, typename P3, typename P4>
bool	operator!= (const CallbackR4< R, P1, P2, P3, P4 > &iA, const CallbackR4< R, P1, P2, P3, P4 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3, typename P4>
CallbackR4< R, P1, P2, P3, P4 >	makeCallback (R(*iFunction)(P1, P2, P3, P4))
	make a CallbackR4 from a function

template<typename R, typename P1, typename P2, typename P3, typename P4>
const CallbackR4< R, P1, P2, P3, P4 > &	makeCallback (const CallbackR4< R, P1, P2, P3, P4 > &iCallback)
	make a CallbackR4 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4>
CallbackR4< R, P1, P2, P3, P4 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4))
	make a CallbackR4 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4>
CallbackR4< R, P1, P2, P3, P4 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4) const)
	make a CallbackR4 from a object and const method

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
bool	operator!= (const CallbackR5< R, P1, P2, P3, P4, P5 > &iA, const CallbackR5< R, P1, P2, P3, P4, P5 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
CallbackR5< R, P1, P2, P3, P4, P5 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5))
	make a CallbackR5 from a function

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
const CallbackR5< R, P1, P2, P3, P4, P5 > &	makeCallback (const CallbackR5< R, P1, P2, P3, P4, P5 > &iCallback)
	make a CallbackR5 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
CallbackR5< R, P1, P2, P3, P4, P5 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5))
	make a CallbackR5 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
CallbackR5< R, P1, P2, P3, P4, P5 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5) const)
	make a CallbackR5 from a object and const method

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
bool	operator!= (const CallbackR6< R, P1, P2, P3, P4, P5, P6 > &iA, const CallbackR6< R, P1, P2, P3, P4, P5, P6 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
CallbackR6< R, P1, P2, P3, P4, P5, P6 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6))
	make a CallbackR6 from a function

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
const CallbackR6< R, P1, P2, P3, P4, P5, P6 > &	makeCallback (const CallbackR6< R, P1, P2, P3, P4, P5, P6 > &iCallback)
	make a CallbackR6 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
CallbackR6< R, P1, P2, P3, P4, P5, P6 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6))
	make a CallbackR6 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
CallbackR6< R, P1, P2, P3, P4, P5, P6 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6) const)
	make a CallbackR6 from a object and const method

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
bool	operator!= (const CallbackR7< R, P1, P2, P3, P4, P5, P6, P7 > &iA, const CallbackR7< R, P1, P2, P3, P4, P5, P6, P7 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
CallbackR7< R, P1, P2, P3, P4, P5, P6, P7 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7))
	make a CallbackR7 from a function

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
const CallbackR7< R, P1, P2, P3, P4, P5, P6, P7 > &	makeCallback (const CallbackR7< R, P1, P2, P3, P4, P5, P6, P7 > &iCallback)
	make a CallbackR7 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
CallbackR7< R, P1, P2, P3, P4, P5, P6, P7 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7))
	make a CallbackR7 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
CallbackR7< R, P1, P2, P3, P4, P5, P6, P7 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7) const)
	make a CallbackR7 from a object and const method

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
bool	operator!= (const CallbackR8< R, P1, P2, P3, P4, P5, P6, P7, P8 > &iA, const CallbackR8< R, P1, P2, P3, P4, P5, P6, P7, P8 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
CallbackR8< R, P1, P2, P3, P4, P5, P6, P7, P8 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8))
	make a CallbackR8 from a function

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
const CallbackR8< R, P1, P2, P3, P4, P5, P6, P7, P8 > &	makeCallback (const CallbackR8< R, P1, P2, P3, P4, P5, P6, P7, P8 > &iCallback)
	make a CallbackR8 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
CallbackR8< R, P1, P2, P3, P4, P5, P6, P7, P8 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8))
	make a CallbackR8 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
CallbackR8< R, P1, P2, P3, P4, P5, P6, P7, P8 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8) const)
	make a CallbackR8 from a object and const method

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
bool	operator!= (const CallbackR9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 > &iA, const CallbackR9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 > &iB)
	return true if two callbacks are different

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
CallbackR9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 >	makeCallback (R(*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9))
	make a CallbackR9 from a function

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
const CallbackR9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 > &	makeCallback (const CallbackR9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 > &iCallback)
	make a CallbackR9 from a function

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
CallbackR9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9))
	make a CallbackR9 from a object and method

template<typename ObjectPtr, typename Object, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
CallbackR9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 >	makeCallback (ObjectPtr iObject, R(Object::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const)
	make a CallbackR9 from a object and const method

Enumeration Type Documentation

◆ DestructionPriorities

template<class T, int destructPriority = destructionPriorityDefault>

enum DestructionPriorities

Destruction priority constants.

Priorities levels below singletonDestructionPriorityBeginUserRange (=500) are reserved for the implementation of Lass, and should not be used by user code (unless you know what you're doing of course ;)

Definition at line 124 of file singleton.h.

Detailed Description

Data Structures

Typedefs

Enumerations

Functions

Enumeration Type Documentation

◆ DestructionPriorities