Return to pa_pool.h CVS log

Up to [parser3project] / parser3 / src / include

found&kill all remaning leaks resulted from pooled::malloc calls
[excluding in gd -- planning complete rewrite extremely ugly code]

/** @file
	Parser: Parser: reference counting classes decls.

	Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)

	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/

#ifndef PA_POOL_H
#define PA_POOL_H

static const char* IDENT_POOL_H="$Date: 2003/02/19 16:19:00 $";

// include

#include "pa_config_includes.h"

#ifdef XML
#	include "gdome.h"
// for xmlChar
#	include "libxml/tree.h"
#endif

// forwards

void *pa_malloc(size_t size);
void *pa_calloc(size_t size);
void pa_free(void *ptr);
void *pa_realloc(void *ptr, size_t size);

class Exception;
class String;
class Charset;
class GdomeDOMString_auto_ptr;

template<typename T> class object_ptr {
	T *ptr;
public:
	typedef T element_type;

	explicit object_ptr(T *ptr = 0) {
		this->ptr=ptr;
		if(ptr)
			ptr->ref();
	}
	template<class B> object_ptr(const object_ptr<B>& src) {
		this->ptr=src.get();
		if(ptr)
			ptr->ref();
	}
	object_ptr(const object_ptr<T>& src) {
		ptr=src.get();
		if(ptr)
			ptr->ref();
	}
	object_ptr(T *ptr, int) {
		this->ptr=ptr;
	}
   object_ptr<T>& operator=(const object_ptr<T>& src) {
		if(this!=&src)
			if(ptr!=src.get()) {
				if(ptr)
					ptr->unref();
				ptr=src.get();
				if(ptr)
					ptr->ref();
			}
		return *this;
	}
    ~object_ptr() {
		if(ptr)
			ptr->unref();
	}
    T& operator*() const {
		return *get();
	}
    T *operator->() const {
		return get();
	}
    T *get() const {
		return ptr;
	}
	operator bool() const {
		return get()!=0;
	}
	bool operator !() const {
		return get()==0;
	}
};

#define DECLARE_OBJECT_PTR(name) \
	typedef object_ptr<name> name##Ptr

/// TEMPLATE CLASS smart_ptr, stolen  from stl:auto_ptr & renamed field/params [not compiled on gcc]
template<class T>
	class smart_ptr {
	bool owns;
	T *ptr;
public:
	typedef T element_type;
	explicit smart_ptr(T *aptr = 0)
		: owns(aptr != 0), ptr(aptr) {}
	smart_ptr(const smart_ptr<T>& src)
		: owns(src.owns), ptr(src.release()) {}
	smart_ptr<T>& operator=(const smart_ptr<T>& src)
		{if (this != &src)
			{if (ptr != src.get())
				{if (owns)
					delete ptr;
				owns = src.owns; }
			else if (src.owns)
				owns = true;
			ptr = src.release(); }
		return (*this); }
	~smart_ptr()
		{if (owns)
			delete ptr; }
	T& operator*() const
		{return (*get()); }
	T *get() const
		{return ptr; }
	T *release() const
		{((smart_ptr<T> *)this)->owns = false;
		return (ptr); }
	operator bool() const {
		return get()!=0;
	}
	operator T*() const {
		return ptr;
	}
	};

// defines

#define override
#define rethrow throw

// memory

inline void *operator new[] (size_t size) {
	return pa_malloc(size);
}
inline void operator delete[] (void *ptr) {
	pa_free(ptr);
}
inline void operator delete (void *ptr) {
	pa_free(ptr);
}

class PA_Allocated {
public:
	/// the sole: instances allocated using our functions
	static void *operator new(size_t size) { 
		return pa_malloc(size);
	}
	static void operator delete(void *ptr) {
		pa_free(ptr);
	}
	static void *malloc(size_t size) {
		return pa_malloc(size);
	}
	static void *calloc(size_t size) {
		return pa_calloc(size);
	}
	static void free(void *ptr) {
		pa_free(ptr);
	}
	static void *realloc(void *ptr, size_t size) {
		return pa_realloc(ptr, size);
	}

};

/** 
	Base for all Parser classes, memory allocation/dallocation goes via pa_malloc/pa_free.
*/
class PA_Object: public PA_Allocated {
	mutable unsigned long freferences;
public:
	PA_Object(): freferences(0) {}
	virtual ~PA_Object() {}
	 
	void ref() const {
		freferences++;
	}
	void unref() const {
		if(freferences) {
			if(--freferences==0)
				delete this;
		}
	}
};
DECLARE_OBJECT_PTR(PA_Object);

// convinient types

typedef smart_ptr<char> CharPtr;

#endif