--- parser3/src/include/pa_array.h	2001/05/16 16:54:00	1.40
+++ parser3/src/include/pa_array.h	2002/02/08 08:30:12	1.53
@@ -1,22 +1,21 @@
 /** @file
-	Parser: array class decl.
+	Parser: Array & Array_iter classes decls.
 
-	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
+	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 
-	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
-
-	$Id: pa_array.h,v 1.40 2001/05/16 16:54:00 parser Exp $
+	$Id: pa_array.h,v 1.53 2002/02/08 08:30:12 paf Exp $
 */
 
 #ifndef PA_ARRAY_H
 #define PA_ARRAY_H
 
-#include <stddef.h>
-
 #include "pa_pool.h"
 #include "pa_types.h"
 #include "pa_string.h"
 
+class Array_iter;
+
 /**	
 	Pooled Array.
 
@@ -34,6 +33,7 @@
 */
 
 class Array : public Pooled {
+	friend class Array_iter;
 public:
 
 	/// Array item type
@@ -45,12 +45,16 @@ public:
 
 	/// for_each iterator function type
 	typedef void (*For_each_func)(Item *value, void *info);
+	/*
+	/// for_each iterator function type, passing item storage address
+	typedef void (*For_each_func_storage)(Item ** value, void *info);
+	*/
 
 	/// first_that iterator function type, const info
-	typedef bool (*First_that_func_const)(Item *value, const void *info);
+	typedef void *(*Item_that_func_const)(Item *value, const void *info);
 
 	/// first_that iterator function type
-	typedef bool (*First_that_func)(Item *value, void *info);
+	typedef void *(*Item_that_func)(Item *value, void *info);
 
 	enum {
 		CR_INITIAL_ROWS_DEFAULT=3, ///< default preallocated row count
@@ -60,23 +64,8 @@ public:
 public:
 
 	Array(Pool& apool, int initial_rows=CR_INITIAL_ROWS_DEFAULT);
+	Array(const Array& source, int offset=0);
 
-	/**
-		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
@@ -90,49 +79,37 @@ public:
 	/// 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;
 	int get_int(int index) const { return reinterpret_cast<int>(get(index)); }
 
 	void put(int index, Item *item);
+	void put_int(int index, int value) { put(index, reinterpret_cast<Item *>(value)); }
 	/// 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, const info
 	void for_each(For_each_func_const func, const void *info=0) const;
-	/*/
+	*/
 
 	/// iterate over all elements
 	void for_each(For_each_func func, void *info=0) const;
 
+	/*/// iterate over all elements, passing address of item storage
+	void for_each(For_each_func_storage func, void *info=0);
+	*/
+
 	/// iterate over all elements until condition, const info
-	void* first_that(First_that_func_const func, const void *info=0) const;
+	void* first_that(Item_that_func_const func, const void *info=0) const;
 
 	/// iterate over all elements until condition
-	void* first_that(First_that_func func, void *info=0) const;
+	void* first_that(Item_that_func func, void *info=0) const;
+
+private:
+
+	/// constructor helper
+	void construct_new(int initial_rows);
 
 private:
 
@@ -166,9 +143,6 @@ private:
 	// array size
 	int fused_rows;
 
-	mutable int cache_chunk_base;
-	mutable Chunk *cache_chunk;
-	
 private:
 
 	bool chunk_is_full() {
@@ -182,4 +156,46 @@ private: //disabled
 	Array& operator = (const Array&) { return *this; }
 };
 
+
+/// handy array iterator
+class Array_iter {
+public:
+
+	Array_iter(const Array& aarray) : array(aarray),
+		chunk(aarray.head),
+		row(chunk->rows),
+		countdown(chunk->count) {
+	}
+
+	/// there are still elements
+	bool has_next() {
+		return !(chunk==array.tail && row==array.append_here);
+	}
+
+	/// quickly extracts next Array::Item
+	Array::Item *next() {
+		// assuming: never called after has_next()!
+		if(countdown==0) { // end of chunk?
+			chunk=row->link;
+			row=chunk->rows;
+			countdown=chunk->count;
+		}
+		Array::Item *result=row->item;
+		row++;  countdown--;
+		return result;
+	}
+
+	/// quickly extracts next Array::Item as const String
+	const String *next_string() { 
+		return const_cast<const String *>(static_cast<String *>(next())); 
+	}
+
+private:
+	const Array& array;
+	const Array::Chunk *chunk;
+	const Array::Chunk::Row *row;
+	int countdown;	
+
+};
+
 #endif