--- parser3/src/include/pa_array.h	2001/01/27 15:21:05	1.2
+++ parser3/src/include/pa_array.h	2001/04/03 05:23:40	1.34
@@ -1,18 +1,11 @@
-/*
-  $Id: pa_array.h,v 1.2 2001/01/27 15:21:05 paf Exp $
-*/
+/** @file
+	Parser: array class decl.
 
-/*
+	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
 
-	Array               Chunk0
-	======              ========
-	head--------------->[ptr]
-	append_here-------->[ptr]
-	link_row            ........
-			.			.
-			.			[ptr]
-			...........>[link to the next chunk]
+	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
 
+	$Id: pa_array.h,v 1.34 2001/04/03 05:23:40 paf Exp $
 */
 
 #ifndef PA_ARRAY_H
@@ -20,36 +13,132 @@
 
 #include <stddef.h>
 
+#include "pa_pool.h"
 #include "pa_types.h"
+#include "pa_string.h"
+
+/**	
+	Pooled Array.
 
-class Pool;
+	Internal structure:
+	@verbatim
+		Array               Chunk0
+		======              ========
+		head--------------->[ptr]
+		append_here-------->[ptr]
+		link_row            ........
+				.			.
+				.			[ptr]
+				...........>[link to the next chunk]
+	@endverbatim
+*/
 
-class Array {
+class Array : public Pooled {
 public:
-	typedef void *Item;
+
+	/// Array item type
+	typedef void Item;
+
+	/// for_each iterator function type
+	typedef void (*For_each_func)(Item *value, void *info);
+
+	/// first_that iterator function type, const info
+	typedef bool (*First_that_func_const)(Item *value, const void *info);
+
+	/// first_that iterator function type
+	typedef bool (*First_that_func)(Item *value, void *info);
 
 	enum {
-		CR_PREALLOCATED_COUNT=10,
-		CR_GROW_PERCENT=60
+		CR_INITIAL_ROWS_DEFAULT=10, ///< default preallocated row count
+		CR_GROW_PERCENT=60 ///< each time the Array chunk_is_full() array expanded()
 	};
 
-private:
-	friend Pool;
+public:
+
+	Array(Pool& apool, int initial_rows=CR_INITIAL_ROWS_DEFAULT);
+
+	/**
+		size Array. how many items are in it. 
+		must be used with quick_get like this:
+		@code
+			int size=src.quick_size();
+			for(int i=0; i<size; i++) {
+				z=src.quick_get(i);
+			}
+		@endcode
+	*/
+	int quick_size() const { 
+		// for quick_get
+		cache_chunk_base=0;
+		cache_chunk=head;
+		return size(); 
+	}
+	/// size Array. how many items are in it
+	int size() const { return fused_rows; }
+	/// append Item to array
+	Array& operator += (Item *src);
+
+	/// dirty hack to allow constant items storage. I long for Array<const Item*>
+	Array& operator += (const Item *src) { return *this+=const_cast<Item*>(src); }
+
+	/// append other Array portion to this one. starting from offset
+	Array& append_array(const Array& src, int offset=0);
+
+	/** 
+		quickly gets some item considering...
+
+		these true:
+			- index increments from 0 to size()-1
+			- index>=0 && index<size()
+			- index>=cache_chunk_base
+	*/
+	Item *quick_get(int index) const {
+		// next chunk will be with "index" row
+		if(!(index<cache_chunk_base+cache_chunk->count)) {
+			int count=cache_chunk->count;
+			cache_chunk_base+=count;
+			cache_chunk=cache_chunk->rows[count].link;
+		}
+		
+		return cache_chunk->rows[index-cache_chunk_base].item;
+	}
+
+	Item *get(int index) const;
+	void put(int index, Item *item);
+	/// convinient way to get strings from Array. I long for Array<const String *>
+	const String *get_string(int index) const { 
+		return const_cast<const String *>(static_cast<String *>(get(index))); 
+	}
+	const String *quick_get_string(int index) const { 
+		return const_cast<const String *>(static_cast<String *>(quick_get(index))); 
+	}
+
+	/// iterate over all elements
+	void for_each(For_each_func func, void *info=0) const;
+
+	/// iterate over all elements until condition, const info
+	void* first_that(First_that_func_const func, const void *info=0) const;
 
-	// the pool I'm allocated on
-	Pool *pool;
+	/// iterate over all elements until condition
+	void* first_that(First_that_func func, void *info=0) const;
+
+private:
 
 	struct Chunk {
 		// the number of rows in chunk
 		int count;
 		union Row {
-			Item item;
+			Item *item;
 			Chunk *link;  // link to the next chunk in chain
 		} rows[1];
 		// next rows are here
 	}
 		*head;  // the head chunk of the chunk chain
 
+	// last allocated chunk
+	// helps appending Arrays
+	Chunk *tail;
+
 	// next append would write to this record
 	Chunk::Row *append_here;
 	
@@ -58,50 +147,24 @@ private:
 	Chunk::Row *link_row;
 
 private:
-	// last chank allocated count
-	int curr_chunk_rows;
 
 	// array size
 	int fused_rows;
 
-	int cache_index;
-	Chunk::Row *cache_row;
-	int cache_countdown;
-	Chunk::Row *cache_link_row;
+	mutable int cache_chunk_base;
+	mutable Chunk *cache_chunk;
 	
 private:
-	// new&constructors made private to enforce factory manufacturing at pool
-	void *operator new(size_t size, Pool *apool);
-
-	void construct(Pool *apool, int initial_rows);
-	Array(Pool *apool) {
-		construct(apool, CR_PREALLOCATED_COUNT); 
-	}
-	Array(Pool *apool, int initial_rows) {
-		construct(apool, initial_rows); 
-	}
-
 
 	bool chunk_is_full() {
 		return append_here == link_row;
 	}
-	void expand();
-
-public:
-
-	int size() { return fused_rows; }
-	Array& operator += (Item src);
-
-	/*
-	void put(int index, Item item);
-	Item get(int index);
-	*/
-	Item& operator [] (int index);
+	void expand(int chunk_rows);
 
 private: //disabled
 
-	Array& operator = (Array& src) { return *this; }
-	Array(Array& src) {}
+	//Array(Array&) { }
+	Array& operator = (const Array&) { return *this; }
 };
 
 #endif