include » ptlib

object.h File Reference

#include "unix/ptlib/contain.h"
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <typeinfo>

Go to the source code of this file.

Classes

class PTrace

Class to encapsulate tracing functions. More...

class PTrace::Block

Class to trace Execution blocks. More...

class PMemoryHeap

Memory heap checking class. More...

struct PMemoryHeap::State

class PMemoryHeap::Wrapper

struct PMemoryHeap::Header

class PMemoryHeapIgnoreAllocationsForScope

class PMemoryAllocationBreakpoint

class PFixedPoolAllocator< Type >

class PVariablePoolAllocator< Type >

class PObject

Ultimate parent class for all objects in the class library. More...

struct PIntSameOrder< type >

struct PIntReversedOrder< type >

Defines

#define P_REMOVE_VIRTUAL_INTERNAL_BASE(fn)   __inline virtual struct ptlib_virtual_function_changed_or_removed ****** fn { return 0; }

#define P_DEPRECATED

#define P_REMOVE_VIRTUAL_INTERNAL(type, fn, body)   P_REMOVE_VIRTUAL_INTERNAL_BASE(fn)

#define P_REMOVE_VIRTUAL_VOID(fn)   P_REMOVE_VIRTUAL_INTERNAL(void, fn, {})

#define P_REMOVE_VIRTUAL(type, fn, ret)   P_REMOVE_VIRTUAL_INTERNAL(type, fn, { return ret; })

#define PTrue   TRUE

#define PFalse   FALSE

#define P_USE_INLINES   0

#define PINLINE

#define P_USE_ASSERTS   1

#define __CLASS__   NULL

#define PAssert(b, msg)   PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,(msg))

This macro is used to assert that a condition must be true.

#define PAssert2(b, cls, msg)   PAssertFuncInline((b), __FILE__,__LINE__,(cls),(msg))

This macro is used to assert that a condition must be true.

#define PAssertOS(b)   PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,POperatingSystemError)

This macro is used to assert that an operating system call succeeds.

#define PAssertNULL(ptr)

This macro is used to assert that a pointer must be non-null.

#define PAssertAlways(msg)   PAssertFunc(__FILE__,__LINE__,__CLASS__,(msg))

This macro is used to assert immediately.

#define PAssertAlways2(cls, msg)   PAssertFunc(__FILE__,__LINE__,(cls),(msg))

This macro is used to assert immediately.

#define PError   (PGetErrorStream())

This macro is used to access the platform specific error output stream.

#define PTRACING   1

#define PTRACE_PARAM(param)   param

#define PTRACE_BLOCK(name)   PTrace::Block __trace_block_instance(__FILE__, __LINE__, name)

Trace an execution block.

#define PTRACE_LINE()

Trace the execution of a line.

#define PTRACE(level, args)

Output trace.

#define PTRACE_IF(level, cond, args)

Output trace on condition.

#define PMEMORY_HEAP   1

#define malloc(s)   PMemoryHeap::Allocate(s, __FILE__, __LINE__, NULL)

Override of system call for memory check system.

#define calloc(n, s)   PMemoryHeap::Allocate(n, s, __FILE__, __LINE__)

Override of system call for memory check system.

#define realloc(p, s)   PMemoryHeap::Reallocate(p, s, __FILE__, __LINE__)

Override of system call for memory check system.

#define free(p)   PMemoryHeap::Deallocate(p, NULL)

Override of system call for memory check system.

#define cfree(p)   PMemoryHeap::Deallocate(p, NULL)

Override of system call for memory check system.

#define PNEW   new (__FILE__, __LINE__)

Macro for overriding system default new operator.

#define PSPECIAL_DELETE_FUNCTION

#define PNEW_AND_DELETE_FUNCTIONS

#define PMEMORY_IGNORE_ALLOCATIONS_FOR_SCOPE   PMemoryHeapIgnoreAllocationsForScope instance_PMemoryHeapIgnoreAllocationsForScope

#define PMEMORY_ALLOCATION_BREAKPOINT(point)   PMemoryAllocationBreakpoint PMemoryAllocationBreakpointInstance(point)

#define PDECLARE_POOL_ALLOCATOR()

#define PDEFINE_POOL_ALLOCATOR(cls)

#define PCLASSINFO(cls, par)

Declare all the standard PTLib class information.

#define PIsDescendant(ptr, cls)   (dynamic_cast<const cls *>(ptr) != NULL)

#define PIsDescendantStr(ptr, str)   ((ptr)->InternalIsDescendant(str))

#define PRemoveConst(cls, ptr)   (const_cast<cls*>(ptr))

#define PDownCast(cls, ptr)   PAssertCast<cls>(dynamic_cast<cls*>(ptr),__FILE__,__LINE__)

#define PDECLARE_CLASS(cls, par)   class cls : public par { PCLASSINFO(cls, par)

Declare a class with PWLib class information.

#define PANSI_CHAR   1

#define PLITTLE_ENDIAN   2

#define PBIG_ENDIAN   3

#define PCHAR8   PANSI_CHAR

#define PARRAYSIZE(array)   ((PINDEX)(sizeof(array)/sizeof(array[0])))

#define PMIN(v1, v2)   ((v1) < (v2) ? (v1) : (v2))

#define PMAX(v1, v2)   ((v1) > (v2) ? (v1) : (v2))

#define PABS(v)   ((v) < 0 ? -(v) : (v))

Typedefs

typedef BOOL PBoolean

typedef PIntSameOrder< char > PChar8

typedef PIntSameOrder< char > PInt8

typedef PIntSameOrder< unsigned
char > PUInt8

Enumerations

enum PStandardAssertMessage {
  PLogicError, POutOfMemory, PNullPointerReference, PInvalidCast,
  PInvalidArrayIndex, PInvalidArrayElement, PStackEmpty, PUnimplementedFunction,
  PInvalidParameter, POperatingSystemError, PChannelNotOpen, PUnsupportedFeature,
  PInvalidWindow, PMaxStandardAssertMessage
}

Standard assert messages for the PAssert macro. More...

Functions

void PAssertFunc (const char *file, int line, const char *className, PStandardAssertMessage msg)

void PAssertFunc (const char *file, int line, const char *className, const char *msg)

void PAssertFunc (const char *full_msg)

bool PAssertFuncInline (bool b, const char *file, int line, const char *className, PStandardAssertMessage msg)

bool PAssertFuncInline (bool b, const char *file, int line, const char *className, const char *msg)

ostream & PGetErrorStream ()

Get the stream being used for error output.

void PSetErrorStream (ostream *strm)

Set the stream to be used for error output.

void * runtime_malloc (size_t bytes)

Allocate memory for the run time library.

void runtime_free (void *ptr)

Free memory allocated by run time library.

void * operator new (size_t nSize, const char *file, int line)

void * operator new[] (size_t nSize, const char *file, int line)

void * operator new (size_t nSize)

void * operator new[] (size_t nSize)

void operator delete (void *ptr)

void operator delete[] (void *ptr)

template<class BaseClass>

BaseClass * PAssertCast (BaseClass *obj, const char *file, int line)

Define Documentation

#define __CLASS__ NULL

#define calloc	(	n,
		s		)	PMemoryHeap::Allocate(n, s, __FILE__, __LINE__)

Override of system call for memory check system.

This macro is used to allocate memory via the memory check system selected with the PMEMORY_CHECK compile time option. It will include the source file and line into the memory allocation to allow the PMemoryHeap class to keep track of the memory block.

#define cfree ( p ) PMemoryHeap::Deallocate(p, NULL)

Override of system call for memory check system.

This macro is used to deallocate memory via the memory check system selected with the PMEMORY_CHECK compile time option. It will include the source file and line into the memory allocation to allow the PMemoryHeap class to keep track of the memory block.

#define free ( p ) PMemoryHeap::Deallocate(p, NULL)

Override of system call for memory check system.

#define malloc ( s ) PMemoryHeap::Allocate(s, __FILE__, __LINE__, NULL)

Override of system call for memory check system.

#define P_DEPRECATED

#define P_REMOVE_VIRTUAL	(	type,
		fn,
		ret	)	P_REMOVE_VIRTUAL_INTERNAL(type, fn, { return ret; })

#define P_REMOVE_VIRTUAL_INTERNAL	(	type,
		fn,
		body	)	P_REMOVE_VIRTUAL_INTERNAL_BASE(fn)

#define P_REMOVE_VIRTUAL_INTERNAL_BASE ( fn ) __inline virtual struct ptlib_virtual_function_changed_or_removed ****** fn { return 0; }

#define P_REMOVE_VIRTUAL_VOID ( fn ) P_REMOVE_VIRTUAL_INTERNAL(void, fn, {})

#define P_USE_ASSERTS 1

#define P_USE_INLINES 0

#define PABS ( v ) ((v) < 0 ? -(v) : (v))

#define PANSI_CHAR 1

#define PARRAYSIZE ( array ) ((PINDEX)(sizeof(array)/sizeof(array[0])))

#define PAssert	(	b,
		msg		)	PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,(msg))

This macro is used to assert that a condition must be true.

If the condition is false then an assert function is called with the source file and line number the macro was instantiated on, plus the message described by the msg parameter. This parameter may be either a standard value from the PStandardAssertMessage enum or a literal string.

#define PAssert2	(	b,
		cls,
		msg	)	PAssertFuncInline((b), __FILE__,__LINE__,(cls),(msg))

This macro is used to assert that a condition must be true.

#define PAssertAlways ( msg ) PAssertFunc(__FILE__,__LINE__,__CLASS__,(msg))

This macro is used to assert immediately.

The assert function is called with the source file and line number the macro was instantiated on, plus the message described by the msg parameter. This parameter may be either a standard value from the PStandardAssertMessage enum or a literal string.

#define PAssertAlways2	(	cls,
		msg		)	PAssertFunc(__FILE__,__LINE__,(cls),(msg))

This macro is used to assert immediately.

#define PAssertNULL ( ptr )

Value:

(((ptr)!=NULL)?(ptr): \
                     (PAssertFunc(__FILE__,__LINE__, __CLASS__, PNullPointerReference),(ptr)))

This macro is used to assert that a pointer must be non-null.

If the pointer is NULL then an assert function is called with the source file and line number the macro was instantiated on, plus the message described by the PNullPointerReference value in the PStandardAssertMessage enum.

Note that this evaluates the expression defined by ptr twice. To prevent incorrect behaviour with this, the macro will assume that the ptr parameter is an L-Value.

#define PAssertOS ( b ) PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,POperatingSystemError)

This macro is used to assert that an operating system call succeeds.

If the condition is false then an assert function is called with the source file and line number the macro was instantiated on, plus the message described by the POperatingSystemError value in the PStandardAssertMessage enum.

#define PBIG_ENDIAN 3

#define PCHAR8 PANSI_CHAR

#define PCLASSINFO	(	cls,
		par		)

Value:

public: \
    typedef cls P_thisClass; \
    static inline const char * Class() \
      { return #cls; } \
    virtual PBoolean InternalIsDescendant(const char * clsName) const \
      { return strcmp(clsName, cls::Class()) == 0 || par::InternalIsDescendant(clsName); } \
    virtual const char * GetClass(unsigned ancestor = 0) const \
      { return ancestor > 0 ? par::GetClass(ancestor-1) : cls::Class(); } \
    virtual Comparison CompareObjectMemoryDirect(const PObject & _obj) const \
      { return (Comparison)memcmp(this, &_obj, sizeof(cls)); } \
    PNEW_AND_DELETE_FUNCTIONS

Declare all the standard PTLib class information.

This macro is used to provide the basic run-time typing capability needed by the library. All descendent classes from the PObject class require these functions for correct operation. Either use this macro or the PDECLARE_CLASS macro.

The use of the PDECLARE_CLASS macro is no longer recommended for reasons of compatibility with documentation systems.

#define PDECLARE_CLASS	(	cls,
		par		)	class cls : public par { PCLASSINFO(cls, par)

Declare a class with PWLib class information.

This macro is used to declare a new class with a single public ancestor. It starts the class declaration and then uses the PCLASSINFO macro to get all the run-time type functions.

The use of this macro is no longer recommended for reasons of compatibility with documentation systems.

#define PDECLARE_POOL_ALLOCATOR ( )

Value:

void * operator new(size_t nSize); \
    void * operator new(size_t nSize, const char * file, int line); \
    void operator delete(void * ptr); \
    void operator delete(void * ptr, const char *, int)

#define PDEFINE_POOL_ALLOCATOR ( cls )

Value:

static PFixedPoolAllocator<cls> cls##_allocator; \
  void * cls::operator new(size_t)                           { return cls##_allocator.allocate(1);               } \
  void * cls::operator new(size_t, const char *, int)        { return cls##_allocator.allocate(1);               } \
  void   cls::operator delete(void * ptr)                    {        cls##_allocator.deallocate((cls *)ptr, 1); } \
  void   cls::operator delete(void * ptr, const char *, int) {        cls##_allocator.deallocate((cls *)ptr, 1); }

#define PDownCast	(	cls,
		ptr		)	PAssertCast<cls>(dynamic_cast<cls*>(ptr),__FILE__,__LINE__)

#define PError (PGetErrorStream())

This macro is used to access the platform specific error output stream.

This is to be used in preference to assuming cerr is always available. On Unix platforms this {is} cerr but for MS-Windows this is another stream that uses the OutputDebugString() Windows API function. Note that a MS-DOS or Windows NT console application would still use cerr.

The PError stream would normally only be used for debugging information as a suitable display is not always available in windowed environments.

The macro is a wrapper for a global variable error stream. The internal variable is initialised to std::cerr for all but MS-Windows and NT GUI applications. An application could change this pointer to a std::ofstream variable of PError output is wished to be redirected to a file.

#define PFalse FALSE

#define PINLINE

#define PIsDescendant	(	ptr,
		cls		)	(dynamic_cast<const cls *>(ptr) != NULL)

#define PIsDescendantStr	(	ptr,
		str		)	((ptr)->InternalIsDescendant(str))

#define PLITTLE_ENDIAN 2

#define PMAX	(	v1,
		v2		)	((v1) > (v2) ? (v1) : (v2))

#define PMEMORY_ALLOCATION_BREAKPOINT ( point ) PMemoryAllocationBreakpoint PMemoryAllocationBreakpointInstance(point)

#define PMEMORY_HEAP 1

#define PMEMORY_IGNORE_ALLOCATIONS_FOR_SCOPE PMemoryHeapIgnoreAllocationsForScope instance_PMemoryHeapIgnoreAllocationsForScope

#define PMIN	(	v1,
		v2		)	((v1) < (v2) ? (v1) : (v2))

#define PNEW new (__FILE__, __LINE__)

Macro for overriding system default new operator.

This macro is used to allocate memory via the memory check system selected with the PMEMORY_CHECK compile time option. It will include the source file and line into the memory allocation to allow the PMemoryHeap class to keep track of the memory block.

This macro could be used instead of the system new operator. Or you can place the line


  define new PNEW

at the begining of the source file, after all declarations that use the PCLASSINFO macro.

#define PNEW_AND_DELETE_FUNCTIONS

Value:

void * operator new(size_t nSize, const char * file, int line) \
      { return PMemoryHeap::Allocate(nSize, file, line, Class()); } \
    void * operator new(size_t nSize) \
      { return PMemoryHeap::Allocate(nSize, NULL, 0, Class()); } \
    void operator delete(void * ptr) \
      { PMemoryHeap::Deallocate(ptr, Class()); } \
    void * operator new(size_t, void * placement) \
      { return placement; } \
    void operator delete(void *, void *) \
      { } \
    void * operator new[](size_t nSize, const char * file, int line) \
      { return PMemoryHeap::Allocate(nSize, file, line, Class()); } \
    void * operator new[](size_t nSize) \
      { return PMemoryHeap::Allocate(nSize, NULL, 0, Class()); } \
    void operator delete[](void * ptr) \
      { PMemoryHeap::Deallocate(ptr, Class()); } \
    PSPECIAL_DELETE_FUNCTION

#define PRemoveConst	(	cls,
		ptr		)	(const_cast<cls*>(ptr))

#define PSPECIAL_DELETE_FUNCTION

#define PTRACE	(	level,
		args		)

Value:

if (PTrace::CanTrace(level)) \
      PTrace::Begin(level, __FILE__, __LINE__) << args << PTrace::End; \
    else (void)0

Output trace.

#define PTRACE_BLOCK ( name ) PTrace::Block __trace_block_instance(__FILE__, __LINE__, name)

Trace an execution block.

This macro creates a trace variable for tracking the entry and exit of program blocks. It creates an instance of the PTraceBlock class that will output a trace message at the line PTRACE_BLOCK() is called and then on exit from the scope it is defined in.

#define PTRACE_IF	(	level,
		cond,
		args	)

Value:

if ((PTrace::CanTrace(level) && (cond))) \
      PTrace::Begin(level, __FILE__, __LINE__) << args << PTrace::End; \
    else (void)0

Output trace on condition.

This macro outputs a trace of any information needed, using standard stream output operators. The output is only made if the trace level set by the SetLevel() function is greater than or equal to the level argument and the conditional is true. Note the conditional is only evaluated if the trace level is sufficient.

#define PTRACE_LINE ( )

Value:

if (PTrace::CanTrace(1)) \
      PTrace::Begin(1, __FILE__, __LINE__) << __FILE__ << '(' << __LINE__ << ')' << PTrace::End; \
    else (void)0

Trace the execution of a line.

This macro outputs a trace of a source file line execution.

#define PTRACE_PARAM ( param ) param

#define PTRACING 1

#define PTrue TRUE

#define realloc	(	p,
		s		)	PMemoryHeap::Reallocate(p, s, __FILE__, __LINE__)

Override of system call for memory check system.

Typedef Documentation

typedef BOOL PBoolean

typedef PIntSameOrder<char> PChar8

typedef PIntSameOrder<char> PInt8

typedef PIntSameOrder<unsigned char> PUInt8

Enumeration Type Documentation

enum PStandardAssertMessage

Standard assert messages for the PAssert macro.

Enumerator:

PLogicError	A logic error occurred.
POutOfMemory	A new or malloc failed.
PNullPointerReference	A reference was made through a NULL pointer.
PInvalidCast	An invalid cast to descendant is required.
PInvalidArrayIndex	An index into an array was negative.
PInvalidArrayElement	A NULL array element object was accessed.
PStackEmpty	A Pop() was made of a stack with no elements.
PUnimplementedFunction	Funtion is not implemented.
PInvalidParameter	Invalid parameter was passed to a function.
POperatingSystemError	Error was returned by Operating System.
PChannelNotOpen	Operation attempted when channel not open.
PUnsupportedFeature	Feature is not supported.
PInvalidWindow	Access through invalid window.
PMaxStandardAssertMessage	Number of standard assert message.

Function Documentation

void operator delete ( void * ptr )

void operator delete[] ( void * ptr )

void* operator new ( size_t nSize )

void* operator new	(	size_t	nSize,
		const char *	file,
		int	line
	)			`[inline]`

void* operator new[] ( size_t nSize )

void* operator new[]	(	size_t	nSize,
		const char *	file,
		int	line
	)			`[inline]`

template<class BaseClass>

BaseClass* PAssertCast	(	BaseClass *	obj,
		const char *	file,
		int	line
	)			`[inline]`

void PAssertFunc ( const char * full_msg )

void PAssertFunc	(	const char *	file,
		int	line,
		const char *	className,
		const char *	msg
	)

void PAssertFunc	(	const char *	file,
		int	line,
		const char *	className,
		PStandardAssertMessage	msg
	)

bool PAssertFuncInline	(	bool	b,
		const char *	file,
		int	line,
		const char *	className,
		const char *	msg
	)			`[inline]`

bool PAssertFuncInline	(	bool	b,
		const char *	file,
		int	line,
		const char *	className,
		PStandardAssertMessage	msg
	)			`[inline]`

ostream& PGetErrorStream ( )

Get the stream being used for error output.

This stream is used for all trace output using the various trace functions and macros.

void PSetErrorStream ( ostream * strm )

Set the stream to be used for error output.

This stream is used for all error output using the PError macro.

Parameters:

strm

New stream for error output

void runtime_free ( void * ptr ) [inline]

Free memory allocated by run time library.

This version of free is used for data that is not allocated using the memory check system, ie was malloc'ed inside the C run time library.

Parameters:

ptr

Memory block to free

void* runtime_malloc ( size_t bytes ) [inline]

Allocate memory for the run time library.

This version of free is used for data that is not to be allocated using the memory check system, ie will be free'ed inside the C run time library.

Parameters:

bytes

Size of block to allocate

Generated on Fri Oct 14 01:44:10 2011 for PTLib by

1.4.7


Classes
class	PTrace
	Class to encapsulate tracing functions. More...
class	PTrace::Block
	Class to trace Execution blocks. More...
class	PMemoryHeap
	Memory heap checking class. More...
struct	PMemoryHeap::State
class	PMemoryHeap::Wrapper
struct	PMemoryHeap::Header
class	PMemoryHeapIgnoreAllocationsForScope
class	PMemoryAllocationBreakpoint
class	PFixedPoolAllocator< Type >
class	PVariablePoolAllocator< Type >
class	PObject
	Ultimate parent class for all objects in the class library. More...
struct	PIntSameOrder< type >
struct	PIntReversedOrder< type >
Defines
#define	P_REMOVE_VIRTUAL_INTERNAL_BASE(fn) __inline virtual struct ptlib_virtual_function_changed_or_removed ****** fn { return 0; }
#define	P_DEPRECATED
#define	P_REMOVE_VIRTUAL_INTERNAL(type, fn, body) P_REMOVE_VIRTUAL_INTERNAL_BASE(fn)
#define	P_REMOVE_VIRTUAL_VOID(fn) P_REMOVE_VIRTUAL_INTERNAL(void, fn, {})
#define	P_REMOVE_VIRTUAL(type, fn, ret) P_REMOVE_VIRTUAL_INTERNAL(type, fn, { return ret; })
#define	PTrue TRUE
#define	PFalse FALSE
#define	P_USE_INLINES 0
#define	PINLINE
#define	P_USE_ASSERTS 1
#define	__CLASS__ NULL
#define	PAssert(b, msg) PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,(msg))
	This macro is used to assert that a condition must be true.
#define	PAssert2(b, cls, msg) PAssertFuncInline((b), __FILE__,__LINE__,(cls),(msg))
	This macro is used to assert that a condition must be true.
#define	PAssertOS(b) PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,POperatingSystemError)
	This macro is used to assert that an operating system call succeeds.
#define	PAssertNULL(ptr)
	This macro is used to assert that a pointer must be non-null.
#define	PAssertAlways(msg) PAssertFunc(__FILE__,__LINE__,__CLASS__,(msg))
	This macro is used to assert immediately.
#define	PAssertAlways2(cls, msg) PAssertFunc(__FILE__,__LINE__,(cls),(msg))
	This macro is used to assert immediately.
#define	PError (PGetErrorStream())
	This macro is used to access the platform specific error output stream.
#define	PTRACING 1
#define	PTRACE_PARAM(param) param
#define	PTRACE_BLOCK(name) PTrace::Block __trace_block_instance(__FILE__, __LINE__, name)
	Trace an execution block.
#define	PTRACE_LINE()
	Trace the execution of a line.
#define	PTRACE(level, args)
	Output trace.
#define	PTRACE_IF(level, cond, args)
	Output trace on condition.
#define	PMEMORY_HEAP 1
#define	malloc(s) PMemoryHeap::Allocate(s, __FILE__, __LINE__, NULL)
	Override of system call for memory check system.
#define	calloc(n, s) PMemoryHeap::Allocate(n, s, __FILE__, __LINE__)
	Override of system call for memory check system.
#define	realloc(p, s) PMemoryHeap::Reallocate(p, s, __FILE__, __LINE__)
	Override of system call for memory check system.
#define	free(p) PMemoryHeap::Deallocate(p, NULL)
	Override of system call for memory check system.
#define	cfree(p) PMemoryHeap::Deallocate(p, NULL)
	Override of system call for memory check system.
#define	PNEW new (__FILE__, __LINE__)
	Macro for overriding system default `new` operator.
#define	PSPECIAL_DELETE_FUNCTION
#define	PNEW_AND_DELETE_FUNCTIONS
#define	PMEMORY_IGNORE_ALLOCATIONS_FOR_SCOPE PMemoryHeapIgnoreAllocationsForScope instance_PMemoryHeapIgnoreAllocationsForScope
#define	PMEMORY_ALLOCATION_BREAKPOINT(point) PMemoryAllocationBreakpoint PMemoryAllocationBreakpointInstance(point)
#define	PDECLARE_POOL_ALLOCATOR()
#define	PDEFINE_POOL_ALLOCATOR(cls)
#define	PCLASSINFO(cls, par)
	Declare all the standard PTLib class information.
#define	PIsDescendant(ptr, cls) (dynamic_cast<const cls *>(ptr) != NULL)
#define	PIsDescendantStr(ptr, str) ((ptr)->InternalIsDescendant(str))
#define	PRemoveConst(cls, ptr) (const_cast<cls*>(ptr))
#define	PDownCast(cls, ptr) PAssertCast<cls>(dynamic_cast<cls*>(ptr),__FILE__,__LINE__)
#define	PDECLARE_CLASS(cls, par) class cls : public par { PCLASSINFO(cls, par)
	Declare a class with PWLib class information.
#define	PANSI_CHAR 1
#define	PLITTLE_ENDIAN 2
#define	PBIG_ENDIAN 3
#define	PCHAR8 PANSI_CHAR
#define	PARRAYSIZE(array) ((PINDEX)(sizeof(array)/sizeof(array[0])))
#define	PMIN(v1, v2) ((v1) < (v2) ? (v1) : (v2))
#define	PMAX(v1, v2) ((v1) > (v2) ? (v1) : (v2))
#define	PABS(v) ((v) < 0 ? -(v) : (v))
Typedefs
typedef BOOL	PBoolean
typedef PIntSameOrder< char >	PChar8
typedef PIntSameOrder< char >	PInt8
typedef PIntSameOrder< unsigned char >	PUInt8
Enumerations
enum	PStandardAssertMessage { PLogicError, POutOfMemory, PNullPointerReference, PInvalidCast, PInvalidArrayIndex, PInvalidArrayElement, PStackEmpty, PUnimplementedFunction, PInvalidParameter, POperatingSystemError, PChannelNotOpen, PUnsupportedFeature, PInvalidWindow, PMaxStandardAssertMessage }
	Standard assert messages for the PAssert macro. More...
Functions
void	PAssertFunc (const char file, int line, const char className, PStandardAssertMessage msg)
void	PAssertFunc (const char file, int line, const char className, const char *msg)
void	PAssertFunc (const char *full_msg)
bool	PAssertFuncInline (bool b, const char file, int line, const char className, PStandardAssertMessage msg)
bool	PAssertFuncInline (bool b, const char file, int line, const char className, const char *msg)
ostream &	PGetErrorStream ()
	Get the stream being used for error output.
void	PSetErrorStream (ostream *strm)
	Set the stream to be used for error output.
void *	runtime_malloc (size_t bytes)
	Allocate memory for the run time library.
void	runtime_free (void *ptr)
	Free memory allocated by run time library.
void *	operator new (size_t nSize, const char *file, int line)
void *	operator new[] (size_t nSize, const char *file, int line)
void *	operator new (size_t nSize)
void *	operator new[] (size_t nSize)
void	operator delete (void *ptr)
void	operator delete[] (void *ptr)
template<class BaseClass>
BaseClass *	PAssertCast (BaseClass obj, const char file, int line)