--- parser3/src/include/pa_pool.h	2001/01/26 15:28:39	1.2
+++ parser3/src/include/pa_pool.h	2001/10/19 14:42:53	1.65
@@ -1,98 +1,172 @@
-/*
+/** @file
+	Parser: pool class decl.
 
-	String				Chunk0
-	======				========
-	head--------->[ptr, size]
-	append_here-------->[ptr, size]
-	link_row      ........
-			.			.
-			.			[ptr, size]
-			...........>[link to the next chunk]
+	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
 
+	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
+
+	$Id: pa_pool.h,v 1.65 2001/10/19 14:42:53 parser Exp $
 */
 
 #ifndef PA_POOL_H
 #define PA_POOL_H
 
-#include <stddef.h>
+#include "pa_config_includes.h"
+
+#ifdef XML
+#include< memory>
+#include <XalanDOM/XalanDOMString.hpp>
+#include <util/TransService.hpp>
+#endif
+
+// forwards
+
+class Exception;
+class Temp_exception;
+class String;
 
-class Pool;
+/** 
+	Pool mechanizm allows users not to free up allocated memory,
+	leaving that problem to 'pools'.
 
-class String {
+	@see Pooled
+*/
+
+class Pool {
 public:
-	enum {
-		CR_PREALLOCATED_COUNT=5,
-		CR_GROW_PERCENT=60
-	};
 
-private:
-	friend Pool;
+	Pool(void *astorage);
+	~Pool();
 
-	// the pool I'm allocated on
-	Pool *pool;
+	void set_context(void *acontext) { fcontext=acontext; }
+	void *get_context() { return fcontext; }
 
-	// last chank allocated count cache
-	int curr_chunk_rows;
-	struct Chunk {
-		// the number of rows per chunk
-		int count;
-		union Row {
-			// chunk item
-			struct {
-				char *ptr;  // pointer to the start of string fragment
-				size_t size;  // length of the fragment
-			} item;
-			Chunk *link;  // link to the next chunk in chain
-		} first[CR_PREALLOCATED_COUNT];
-		// next rows are here
-		Chunk *preallocated_link;
-	}
-		head;  // the head chunk of the chunk chain
+	void set_tag(void *atag) { ftag=atag; }
+	void *tag() { return ftag; }
 
-	// next append would write to this record
-	Chunk::Row *append_here;
-	
-	// the address of place where lies address 
-	// of the link to the next chunk to allocate
-	Chunk::Row *link_row;
-
-	// new&constructors made private to enforce factory manufacturing at pool
-	void *operator new(size_t size, Pool *apool);
-
-	void construct(Pool *apool);
-	String(Pool *apool) { 
-		construct(apool); 
+	/// allocates some bytes on pool
+	void *malloc(size_t size/*, int place=0*/) {
+		return check(real_malloc(size/*, place*/), size);
+	}
+	/// allocates some bytes clearing them with zeros
+	void *calloc(size_t size) {
+		return check(real_calloc(size), size);
 	}
-	String(Pool *apool, char *src) {
-		construct(apool);
-		*this+=src;
+
+	/// registers a routine to clean up non-pooled allocations
+	void register_cleanup(void (*cleanup) (void *), void *data) {
+		if(!real_register_cleanup(cleanup, data))
+			fail_register_cleanup();
 	}
 
-	bool chunk_is_full() {
-		return append_here == link_row;
+	/// resets transcoder if they change charset 
+	void set_charset(const String &charset);
+	/// returns current charset
+	const String& get_charset() { return *charset; }
+
+private:
+
+	void *fstorage;
+	void *fcontext;
+	void *ftag;
+	const String *charset;
+
+private: 
+	
+	//{
+	/// @name implementation defined
+    void *real_malloc(size_t size/*, int place*/);
+    void *real_calloc(size_t size);
+	bool real_register_cleanup(void (*cleanup) (void *), void *data);
+	//}
+
+private: 
+
+	/// checks whether mem allocated OK. throws exception otherwise
+	void *check(void *ptr, size_t size) {
+		if(ptr)
+			return ptr;
+
+		fail_alloc(size);
+
+		// never reached
+		return 0;
 	}
-	void expand();
+	/// throws allocation exception
+	void fail_alloc(size_t size) const;
+
+	/// throws register cleanup exception
+	void fail_register_cleanup() const;
+
+#ifdef XML
 
 public:
+	/// converts Xalan string to char *
+	const char *transcode_cstr(const XalanDOMString& s);
+	/// converts Xalan string to parser String
+	String& transcode(const XalanDOMString& s);
+	/// converts char * to Xalan string
+	std::auto_ptr< XalanDOMString> transcode_buf(const char *buf, size_t buf_size);
+	/// converts parser String to Xalan string
+	std::auto_ptr<XalanDOMString> transcode(const String& s);
+
+private:
 
-	size_t size();
-	char *c_str();
-	String& operator += (char *src);
+	void set_charset(const char *new_scharset);
+	void update_transcoder();
+
+private:
+
+	XMLTranscoder *transcoder;
+
+#endif
+
+private: //disabled
+
+	Pool(const Pool&);
+	Pool& operator= (const Pool&);
 };
 
-class Pool {
+/** 
+	Base for all classes that are allocated in 'pools'.
+
+	Holds Pool object. Contains useful wrappers to it's methods.
+
+	@see NEW
+*/
+class Pooled {
+	// the pool i'm allocated on
+	Pool *fpool;
 public:
-	Pool();
-	~Pool();
-    void *alloc(size_t size);
-    void *calloc(size_t size);
 
-	String *makeString() { 
-		return new(this) String(this);
-	}
-	String *makeString(char *src) {
-		return new(this) String(this, src);
-	}
+	/// the Pooled-sole: Pooled instances can be allocated in Pool rather then on heap
+	static void *operator new(size_t size, Pool& apool) { 
+		return apool.malloc(size/*, 1*/);
+	}
+
+	Pooled(Pool& apool) : fpool(&apool) {}
+
+	/// my pool
+	Pool& pool() const { return *fpool; }
+
+	/** 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; }
+
+	//{
+	/// @name useful wrapper around pool
+	void *malloc(size_t size) const { return fpool->malloc(size); }
+	void *calloc(size_t size) const { return fpool->calloc(size); }
+	void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }
+#ifdef XML
+	const char *transcode_cstr(const XalanDOMString& s) { return fpool->transcode_cstr(s); }
+	String& transcode(const XalanDOMString& s) { return fpool->transcode(s); }
+#endif
+	//}
 };
+/// useful macro for creating objects on current Pooled object Pooled::pool()
+#define NEW new(pool())
 
 #endif