object.h File Reference

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

Go to the source code of this file.

Classes
class	PTrace
class	PTrace::Block
class	PObject
Defines
#define	_BADOFF   -1
#define	P_USE_INLINES   0
#define	PINLINE
#define	P_USE_ASSERTS   1
#define	__CLASS__   NULL
#define	PAssert(b, m)   PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,(m))
#define	PAssert2(b, c, m)   PAssertFuncInline((b), __FILE__,__LINE__,(c),(m))
#define	PAssertOS(b)   PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,POperatingSystemError)
#define	PAssertNULL(p)
#define	PAssertAlways(m)   PAssertFunc(__FILE__,__LINE__,__CLASS__,(m))
#define	PAssertAlways2(c, m)   PAssertFunc(__FILE__,__LINE__,(c),(m))
#define	PError   (PGetErrorStream())
#define	PTRACING   1
#define	PTRACE_PARAM(param)   param
#define	PTRACE_BLOCK(name)   PTrace::Block __trace_block_instance(__FILE__, __LINE__, name)
#define	PTRACE_LINE()
#define	PTRACE(level, args)
#define	PTRACE_IF(level, cond, args)
#define	PMEMORY_HEAP   0
#define	PNEW   new
#define	PNEW_AND_DELETE_FUNCTIONS
#define	runtime_malloc(s)   malloc(s)
#define	runtime_free(p)   free(p)
#define	PMEMORY_IGNORE_ALLOCATIONS_FOR_SCOPE
#define	PMEMORY_ALLOCATION_BREAKPOINT(point)
#define	PCLASSINFO(cls, par)
#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)
#define	PANSI_CHAR   1
#define	PLITTLE_ENDIAN   2
#define	PBIG_ENDIAN   3
#define	PI_SAME(name, type)
#define	PI_LOOP(src, dst)
#define	PI_DIFF(name, type)
#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 long	_Ios_Fmtflags
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 ()
void	PSetErrorStream (ostream *strm)
template<class BaseClass>
BaseClass *	PAssertCast (BaseClass *obj, const char *file, int line)
	PI_SAME (PChar8, char)
	PI_SAME (PInt8, signed char)
	PI_SAME (PUInt8, unsigned char)

---

Define Documentation

#define __CLASS__   NULL

#define _BADOFF   -1

#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,
		m		)	PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,(m))

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,
		c,
		m		)	PAssertFuncInline((b), __FILE__,__LINE__,(c),(m))

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. The c# parameter specifies the class name that the error occurred in

#define PAssertAlways

(

m

)

PAssertFunc(__FILE__,__LINE__,__CLASS__,(m))

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	(	c,
		m		)	PAssertFunc(__FILE__,__LINE__,(c),(m))

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 PAssertNULL

(

p

)

Value:

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

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: \
    static inline const char * Class() \
      { return #cls; } \
    virtual BOOL 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 PWlib 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 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 {} 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 PErrorStream# which is a pointer to an ostream#. The variable is initialised to cerr# for all but MS-Windows and NT GUI applications. An application could change this pointer to a ofstream# variable of PError# output is wished to be redirected to a file.

#define PI_DIFF	(	name,
		type		)

Value:

struct name { \
    name() : data(0) { } \
    name(type value) : data(0) { operator=(value); } \
    name(const name & value) : data(value.data) { } \
    name & operator =(type value) { PI_LOOP(value, data); return *this; } \
    name & operator =(const name & value) { data = value.data; return *this; } \
    operator type() const { type value; PI_LOOP(data, value); return value; } \
    friend ostream & operator<<(ostream & s, const name & value) { return s << (type)value; } \
    friend istream & operator>>(istream & s, name & v) { type val; s >> val; v = val; return s; } \
    private: type data; \
  }

#define PI_LOOP	(	src,
		dst		)

Value:

BYTE *s = ((BYTE *)&src)+sizeof(src); BYTE *d = (BYTE *)&dst; \
    while (s != (BYTE *)&src) *d++ = *--s;

#define PI_SAME	(	name,
		type		)

Value:

struct name { \
    name() : data(0) { } \
    name(type value) : data(value) { } \
    name(const name & value) : data(value.data) { } \
    name & operator =(type value) { data = value; return *this; } \
    name & operator =(const name & value) { data = value.data; return *this; } \
    operator type() const { return data; } \
    friend ostream & operator<<(ostream & s, const name & v) { return s << v.data; } \
    friend istream & operator>>(istream & s, name & v) { return s >> v.data; } \
    private: type data; \
  }

#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

)

#define PMEMORY_HEAP   0

#define PMEMORY_IGNORE_ALLOCATIONS_FOR_SCOPE

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

#define PNEW   new

#define PNEW_AND_DELETE_FUNCTIONS

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

#define PTRACE	(	level,
		args		)

Value:

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

Output trace. 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 PSetTraceLevel# function is greater than or equal to the level# argument.

#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))) ; else \
      PTrace::Begin(level, __FILE__, __LINE__) << args << PTrace::End

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 PSetTraceLevel# 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)) ; else \
      PTrace::Begin(1, __FILE__, __LINE__) << __FILE__ << '(' << __LINE__ << ')' << PTrace::End

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 runtime_free

(

p

)

free(p)

#define runtime_malloc

(

s

)

malloc(s)

---

Typedef Documentation

typedef long _Ios_Fmtflags

---

Enumeration Type Documentation

enum PStandardAssertMessage

Standard assert messages for the PAssert macro.

Enumerator:

PLogicError
POutOfMemory
PNullPointerReference
PInvalidCast
PInvalidArrayIndex
PInvalidArrayElement
PStackEmpty
PUnimplementedFunction
PInvalidParameter
POperatingSystemError
PChannelNotOpen
PUnsupportedFeature
PInvalidWindow
PMaxStandardAssertMessage

---

Function Documentation

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.

PI_SAME	(	PUInt8	,
		unsigned	char
	)

PI_SAME	(	PInt8	,
		signed	char
	)

PI_SAME	(	PChar8	,
		char
	)

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

---