--- parser3/src/main/Attic/pa_array.C	2001/01/29 15:56:04	1.7
+++ parser3/src/main/Attic/pa_array.C	2001/03/11 08:16:34	1.22
@@ -1,19 +1,21 @@
 /*
-  $Id: pa_array.C,v 1.7 2001/01/29 15:56:04 paf Exp $
+	Parser
+	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
+	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
+
+	$Id: pa_array.C,v 1.22 2001/03/11 08:16:34 paf Exp $
 */
 
 #include <string.h>
 
 #include "pa_pool.h"
+#include "pa_array.h"
+#include "pa_exception.h"
 
-void *Array::operator new(size_t size, Pool *apool) {
-	return apool->malloc(size);
-}
-
-Array::Array(Pool *apool, int initial_rows) :
-	pool(apool) {
+Array::Array(Pool& apool, int initial_rows) :
+	Pooled(apool) {
 	head=tail=static_cast<Chunk *>(
-		pool->malloc(sizeof(int)+sizeof(Chunk::Row)*initial_rows+sizeof(Chunk *)));
+		malloc(sizeof(int)+sizeof(Chunk::Row)*initial_rows+sizeof(Chunk *)));
 	head->count=initial_rows;
 	append_here=head->rows;
 	link_row=&head->rows[initial_rows];
@@ -25,8 +27,11 @@ Array::Array(Pool *apool, int initial_ro
 }
 
 void Array::expand(int chunk_rows) {
+	if(chunk_rows<CR_INITIAL_ROWS_DEFAULT)
+		chunk_rows=CR_INITIAL_ROWS_DEFAULT;
+
 	Chunk *chunk=tail=static_cast<Chunk *>(
-		pool->malloc(sizeof(int)+sizeof(Chunk::Row)*chunk_rows+sizeof(Chunk *)));
+		malloc(sizeof(int)+sizeof(Chunk::Row)*chunk_rows+sizeof(Chunk *)));
 	chunk->count=chunk_rows;
 	link_row->link=chunk;
 	append_here=chunk->rows;
@@ -35,7 +40,7 @@ void Array::expand(int chunk_rows) {
 }
 
 
-Array& Array::operator += (Item src) {
+Array& Array::operator += (Item *src) {
 	if(chunk_is_full())
 		expand(tail->count*CR_GROW_PERCENT/100);
 
@@ -45,11 +50,11 @@ Array& Array::operator += (Item src) {
 	return *this;
 }
 
-Array::Item& Array::operator [] (int index) {
+Array::Item *Array::get(int index) const {
 	if(!(index>=0 && index<size())) {
-		// FIX: some sort of thread-global error
-		Item *result=0;
-		return *result;
+		THROW(0, 0, 0, 
+			"Array::get(%d) out of range [0..%d]", index, size()-1);
+		return 0;
 	}
 
 	// if they ask index to the left of cached position, forget cache
@@ -68,43 +73,75 @@ Array::Item& Array::operator [] (int ind
 	return cache_chunk->rows[index-cache_chunk_base].item;
 }
 
-Array& Array::operator += (Array& src) {
-	int src_used_rows=src.fused_rows;
+void Array::put(int index, Item *item) {
+	if(!(index>=0 && index<size())) {
+		THROW(0, 0, 0, 
+			"Array::put(%d) out of range [0..%d]", index, size()-1);
+		return;
+	}
+
+	// if they ask index to the left of cached position, forget cache
+	if(index<cache_chunk_base) {
+		cache_chunk_base=0;
+		cache_chunk=head;
+	}
+
+	// navigate to chunk with "index" row
+	while(!(index>=cache_chunk_base && index<cache_chunk_base+cache_chunk->count)) {
+		int count=cache_chunk->count;
+		cache_chunk_base+=count;
+		cache_chunk=cache_chunk->rows[count].link;
+	}
+
+	cache_chunk->rows[index-cache_chunk_base].item=item;
+}
+
+Array& Array::append_array(const Array& src, int offset) {
+	int src_rows_to_copy=src.fused_rows-offset;
 	int last_chunk_rows_left=link_row-append_here;
 	
 	// our last chunk too small for src to fit?
-	if(src_used_rows>last_chunk_rows_left) {
+	if(src_rows_to_copy>last_chunk_rows_left) {
 		// shrink last chunk to used rows
 		tail->count-=last_chunk_rows_left;
 		link_row=append_here;
 
 		// append new src_used_rows-ed chunk 
-		expand(src_used_rows);
+		expand(src_rows_to_copy);
 	}
 
-	Chunk *src_chunk=src.head; 
+	Chunk *src_chunk=src.head;
 	Chunk::Row *dest_rows=append_here;
-	int rows_left_to_copy=src_used_rows;
+	int rows_left_to_copy=src.fused_rows;
+	int rows_left_to_skip=offset;
 	while(true) {
 		int src_count=src_chunk->count;
 		Chunk *next_chunk=src_chunk->rows[src_count].link;
 		if(next_chunk) {
 			// not last source chunk
 			// taking it all
-			memcpy(dest_rows, src_chunk->rows, sizeof(Chunk::Row)*src_count);
-			dest_rows+=src_count;
+			int rows_to_copy_now=src_count-rows_left_to_skip;
+			if(rows_to_copy_now>0)
+				memcpy(dest_rows, src_chunk->rows+rows_left_to_skip, 
+					sizeof(Chunk::Row)*rows_to_copy_now);
+			else
+				rows_left_to_skip-=src_count;
+
+			dest_rows+=rows_to_copy_now;
 			rows_left_to_copy-=src_count;
-			
 			src_chunk=next_chunk;
 		} else {
 			// the last source chunk
 			// taking only those rows of chunk that _left_to_copy
-			memcpy(dest_rows, src_chunk->rows, sizeof(Chunk::Row)*rows_left_to_copy);
+			int rows_to_copy_now=rows_left_to_copy-rows_left_to_skip;
+			if(rows_to_copy_now>0)
+				memcpy(dest_rows, src_chunk->rows+rows_left_to_skip, 
+					sizeof(Chunk::Row)*rows_to_copy_now);
 			break;
 		}
 	}
-	append_here+=src_used_rows;
-	fused_rows+=src_used_rows;
+	append_here+=src_rows_to_copy;
+	fused_rows+=src_rows_to_copy;
 
 	return *this;
 }