--- parser3/src/main/Attic/pa_hash.C	2001/01/29 20:10:32	1.8
+++ parser3/src/main/Attic/pa_hash.C	2001/05/17 19:33:33	1.35
@@ -1,5 +1,11 @@
-/*
-  $Id: pa_hash.C,v 1.8 2001/01/29 20:10:32 paf Exp $
+/** @file
+	Parser: hash class.
+
+	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
+
+	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
+
+	$Id: pa_hash.C,v 1.35 2001/05/17 19:33:33 parser Exp $
 */
 
 /*
@@ -10,44 +16,38 @@
 	For more information about Zend please visit http://www.zend.com/
 */
 
-#include "pa_pool.h"
-#include "pa_threads.h"
+#include "pa_hash.h"
 
 void *Hash::Pair::operator new(size_t size, Pool& apool) {
 	return apool.malloc(size);
 }
 
 /* Zend comment: Generated on an Octa-ALPHA 300MHz CPU & 2.5GB RAM monster */
-uint Hash::sizes[]={
+uint Hash::allocates[]={
 	5, 11, 19, 53, 107, 223, 463, 983, 1979, 3907, 7963, 
 	16229, 32531, 65407, 130987, 262237, 524521, 1048793, 
 	2097397, 4194103, 8388857, 16777447, 33554201, 67108961, 
 	134217487, 268435697, 536870683, 1073741621, 2147483399};
-int Hash::sizes_count=
-	sizeof(sizes)/sizeof(uint);
+int Hash::allocates_count=
+	sizeof(allocates)/sizeof(uint);
 
-void *Hash::operator new(size_t size, Pool& apool) {
-	return apool.malloc(size);
-}
 
-Hash::Hash(Pool& apool, bool athread_safe) :
-	pool(apool),
-	thread_safe(athread_safe) {
-	
-	size=sizes[size_index=0];
-	threshold=size*THRESHOLD_PERCENT/100;
+void Hash::construct(Pool& apool) {
+	allocated=allocates[allocates_index=0];
+	threshold=allocated*THRESHOLD_PERCENT/100;
 	used=0;
-	refs=static_cast<Pair **>(pool.calloc(sizeof(Pair *)*size));
+	refs=static_cast<Pair **>(calloc(sizeof(Pair *)*allocated));
 }
 
 void Hash::expand() {
-	int old_size=size;
+	int old_size=allocated;
 	Pair **old_refs=refs;
 
 	// allocated bigger refs array
-	size_index=size_index+1<sizes_count?size_index+1:sizes_count-1;
-	size=sizes[size_index];
-	refs=static_cast<Pair **>(pool.calloc(sizeof(Pair *)*size));
+	allocates_index=allocates_index+1<allocates_count?allocates_index+1:allocates_count-1;
+	allocated=allocates[allocates_index];
+	threshold=allocated*THRESHOLD_PERCENT/100;
+	refs=static_cast<Pair **>(calloc(sizeof(Pair *)*allocated));
 
 	// rehash
 	Pair **old_ref=old_refs;
@@ -55,7 +55,7 @@ void Hash::expand() {
 		for(Pair *pair=*old_ref++; pair; ) {
 			Pair *linked_pair=pair->link;
 
-			uint new_index=pair->code%size;
+			uint new_index=pair->code%allocated;
 			Pair **new_ref=&refs[new_index];
 			pair->link=*new_ref;
 			*new_ref=pair;
@@ -64,9 +64,9 @@ void Hash::expand() {
 		}
 }
 
-uint Hash::generic_code(uint aresult, char *start, uint size) {
+uint Hash::generic_code(uint aresult, const char *start, uint allocated) {
 	uint result=aresult, g;
-	char *end=start+size;
+	const char *end=start+allocated;
 
 	while (start<end) {
 		result=(result<<4)+*start++;
@@ -78,30 +78,97 @@ uint Hash::generic_code(uint aresult, ch
 	return result;
 }
 
-void Hash::put(Key& key, Value *value) {  SYNCHRONIZED(thread_safe);
+bool Hash::put(const Key& key, Val *value) {
 	if(full()) 
 		expand();
 
 	uint code=key.hash_code();
-	uint index=code%size;
+	uint index=code%allocated;
 	Pair **ref=&refs[index];
 	for(Pair *pair=*ref; pair; pair=pair->link)
 		if(pair->code==code && pair->key==key) {
 			// found a pair with the same key
 			pair->value=value;
-			return;
+			return true;
 		}
 	
 	// proper pair not found -- create&link_in new pair
-	*ref=new(pool) Pair(code, key, value, *ref);
+	if(!*ref) // root cell were used?
+		used++; // not, we'll use it and record the fact
+	*ref=NEW Pair(code, key, value, *ref);
+	return false;
 }
 
-Hash::Value *Hash::get(Key& key) {  SYNCHRONIZED(thread_safe);
+Hash::Val *Hash::get(const Key& key) const {
 	uint code=key.hash_code();
-	uint index=code%size;
+	uint index=code%allocated;
 	for(Pair *pair=refs[index]; pair; pair=pair->link)
 		if(pair->code==code && pair->key==key)
 			return pair->value;
 	
 	return 0;
 }
+
+bool Hash::put_replace(const Key& key, Val *value) {
+	uint code=key.hash_code();
+	uint index=code%allocated;
+	for(Pair *pair=refs[index]; pair; pair=pair->link)
+		if(pair->code==code && pair->key==key) {
+			// found a pair with the same key, replacing
+			pair->value=value;
+			return true;
+		}
+
+	// proper pair not found 
+	return false;
+}
+
+bool Hash::put_dont_replace(const Key& key, Val *value) {
+	if(full()) 
+		expand();
+
+	uint code=key.hash_code();
+	uint index=code%allocated;
+	Pair **ref=&refs[index];
+	for(Pair *pair=*ref; pair; pair=pair->link)
+		if(pair->code==code && pair->key==key) {
+			// found a pair with the same key, NOT replacing
+			return true;
+		}
+
+	// proper pair not found -- create&link_in new pair
+	*ref=NEW Pair(code, key, value, *ref);
+	if(!*ref) // root cell were used?
+		used++; // not, we'll use it and record the fact
+	return false;
+}
+
+void Hash::merge_dont_replace(const Hash& src) {
+	for(int i=0; i<src.allocated; i++)
+		for(Pair *pair=src.refs[i]; pair; pair=pair->link)
+			put_dont_replace(pair->key, pair->value);
+	// MAY:optimize this.allocated==src.allocated case
+}
+
+void Hash::for_each(For_each_func func, void *info) const {
+	Pair **ref=refs;
+	for(int index=0; index<allocated; index++)
+		for(Pair *pair=*ref++; pair; pair=pair->link)
+			if(pair->value)
+				(*func)(pair->key, pair->value, info);
+}
+
+Hash::Val* Hash::first_that(First_that_func func, void *info) const {
+	Pair **ref=refs;
+	for(int index=0; index<allocated; index++)
+		for(Pair *pair=*ref++; pair; pair=pair->link)
+			if(pair->value)
+				if((*func)(pair->key, pair->value, info))
+					return pair->value;
+	return 0;
+}
+
+void Hash::clear() {
+	memset(refs, 0, sizeof(*refs)*allocated);
+	used=0;
+}