--- parser3/src/include/pa_pool.h	2002/10/15 15:12:57	1.85
+++ parser3/src/include/pa_pool.h	2003/01/28 12:11:49	1.86.2.16
@@ -1,7 +1,7 @@
 /** @file
-	Parser: pool class decl.
+	Parser: Parser: reference counting classes decls.
 
-	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
 
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
@@ -9,7 +9,7 @@
 #ifndef PA_POOL_H
 #define PA_POOL_H
 
-static const char* IDENT_POOL_H="$Date: 2002/10/15 15:12:57 $";
+static const char* IDENT_POOL_H="$Date: 2003/01/28 12:11:49 $";
 
 #include "pa_config_includes.h"
 
@@ -19,6 +19,11 @@ static const char* IDENT_POOL_H="$Date:
 #	include "libxml/tree.h"
 #endif
 
+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);
+
 // forwards
 
 class Exception;
@@ -26,12 +31,12 @@ class String;
 class Charset;
 class GdomeDOMString_auto_ptr;
 
-/** 
+/* * 
 	Pool mechanizm allows users not to free up allocated memory,
 	leaving that problem to 'pools'.
 
 	@see Pooled
-*/
+* /
 
 class Pool {
 public:
@@ -148,6 +153,8 @@ private: //disabled
 	Pool(const Pool&);
 	Pool& operator= (const Pool&);
 };
+*/
+
 
 /** 
 	Base for all classes that are allocated in 'pools'.
@@ -155,7 +162,7 @@ private: //disabled
 	Holds Pool object. Contains useful wrappers to it's methods.
 
 	@see NEW
-*/
+* /
 
 // all classes that are members parents of packed class [String] 
 // sould be packed also to avoid sparc odd st/lduh problem
@@ -178,7 +185,7 @@ public:
 	/** used for moving objects from one pool to another. 
 		in between object can have no pool and can not be used
 		@see SQL_Driver_manager
-	*/
+	* /
 	void set_pool(Pool *apool) { fpool=apool; }
 
 	//{
@@ -209,5 +216,161 @@ public:
 #include "pa_pragma_pack_end.h"
 /// useful macro for creating objects on current Pooled object Pooled::pool()
 #define NEW new(pool())
+*/
+
+#define override
+#define rethrow throw
+
+void *operator new(size_t size) { 
+	return pa_malloc(size);
+}
+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 *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()=0;
+	 
+	void ref() const {
+		freferences++;
+	}
+	void unref() const {
+		if(freferences) {
+			if(--freferences==0)
+				delete this;
+		}
+	}
+};
+
+
+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();
+	}
+	object_ptr(const object_ptr<T>& src) {
+		ptr=src.get();
+		ptr->ref();
+	}
+   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;
+	}
+	// so one could object_ptr<const T> = object_ptr<T>
+	operator object_ptr<const T>() const{
+		return *this;
+	}
+	operator bool() const {
+		return get()!=0;
+	}
+	operator !() const {
+		return get()==0;
+	}
+};
+
+#define DECLARE_OBJECT_PTR(name) \
+	typedef object_ptr<name> name##Ptr; \
+	const object_ptr<name> name##PtrZero(0);
+
+/// TEMPLATE CLASS smart_ptr, stolen from stl:auto_ptr
+template<class T>
+	class smart_ptr {
+public:
+	typedef T element_type;
+	explicit smart_ptr(T *_P = 0)
+		: _Owns(_P != 0), _Ptr(_P) {}
+	smart_ptr(const smart_ptr<T>& _Y)
+		: _Owns(_Y._Owns), _Ptr(_Y.release()) {}
+	smart_ptr<T>& operator=(const smart_ptr<T>& _Y)
+		{if (this != &_Y)
+			{if (_Ptr != _Y.get())
+				{if (_Owns)
+					delete _Ptr;
+				_Owns = _Y._Owns; }
+			else if (_Y._Owns)
+				_Owns = true;
+			_Ptr = _Y.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); }
+	// so one could smart_ptr<const T> = smart_ptr<T>
+	operator smart_ptr<const T>() const {
+		return *this;
+	}
+	operator bool() const {
+		return get()!=0;
+	}
+	operator T*() const {
+		return _Ptr;
+	}
+private:
+	bool _Owns;
+	T *_Ptr;
+	};
+
+// convinient types
+
+typedef smart_ptr<char> CharPtr;
+const CharPtr CharPtrZero(0);
 
 #endif