--- parser3/src/include/pa_array.h	2001/01/29 20:10:31	1.11
+++ parser3/src/include/pa_array.h	2001/03/19 15:29:37	1.24
@@ -1,8 +1,24 @@
-/*
-  $Id: pa_array.h,v 1.11 2001/01/29 20:10:31 paf Exp $
+/** @file
+	Parser
+	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
+	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
+
+	$Id: pa_array.h,v 1.24 2001/03/19 15:29:37 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"
+
+/**	@brief	
+	Pooled Array.
+
+	Internal structure: @verbatim	
 
 	Array               Chunk0
 	======              ========
@@ -13,44 +29,64 @@
 			.			[ptr]
 			...........>[link to the next chunk]
 
+	@endverbatim
 */
 
-#ifndef PA_ARRAY_H
-#define PA_ARRAY_H
-
-#include <stddef.h>
-
-#include "pa_types.h"
-#include "pa_string.h"
-
-class Pool;
-
-class Array {
+class Array : public Pooled {
 public:
 
-	typedef void Item;
+	typedef void Item; ///< Array item type
 
 	enum {
-		CR_INITIAL_ROWS_DEFAULT=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()
 	};
 
 public:
 
-	void *operator new(size_t size, Pool& apool);
 	Array(Pool& apool, int initial_rows=CR_INITIAL_ROWS_DEFAULT);
 
-	int size() { return fused_rows; }
+	/// size Array. how many items are in it
+	int size() const { 
+		// for get and quick_get
+		cache_chunk_base=0;
+		cache_chunk=head;
+		return fused_rows; 
+	}
+	/// append Item to array
 	Array& operator += (Item *src);
-	Array& append_array(Array& src);
-	Item *get(int index);
-	char *get_cstr(int index) { return static_cast<char *>(get(index)); }
-	String *get_string(int index) { return static_cast<String *>(get(index)); }
 
-protected:
+	/// 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);
+
+	/** @brief
+		quickly get some item considering
 
-	// the pool I'm allocated on
-	Pool& pool;
+		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 static_cast<const String *>(get(index)); 
+	}
 
 private:
 
@@ -81,8 +117,8 @@ private:
 	// array size
 	int fused_rows;
 
-	int cache_chunk_base;
-	Chunk *cache_chunk;
+	mutable int cache_chunk_base;
+	mutable Chunk *cache_chunk;
 	
 private:
 
@@ -94,7 +130,7 @@ private:
 private: //disabled
 
 	//Array(Array&) { }
-	Array& operator = (Array&) { return *this; }
+	Array& operator = (const Array&) { return *this; }
 };
 
 #endif