--- parser3/src/include/pa_hash.h	2001/01/29 11:17:49	1.6
+++ parser3/src/include/pa_hash.h	2001/01/29 22:34:57	1.13
@@ -1,5 +1,5 @@
 /*
-  $Id: pa_hash.h,v 1.6 2001/01/29 11:17:49 paf Exp $
+  $Id: pa_hash.h,v 1.13 2001/01/29 22:34:57 paf Exp $
 */
 
 /*
@@ -23,16 +23,40 @@ public:
 	typedef String Key;
 	typedef void Value;
 
+public:
+
+	void *operator new(size_t size, Pool& apool);
+	Hash(Pool& apool, bool athread_safe);
+
+	// useful generic hash function
+	static uint generic_code(uint aresult, const char *start, uint size);
+
+	// put a [value] under the [key]
+	/*SYNCHRONIZED*/ void put(const Key& key, Value *value);
+
+	// get associated [value] by the [key]
+	/*SYNCHRONIZED*/ Value *get(const Key& key);
+
+	void put(const Key& key, int     value) { put(key, reinterpret_cast<Value *>(value)); }
+	void put(const Key& key, String *value) { put(key, static_cast<Value *>(value)); }
+
+	int get_int(const Key& key) { return reinterpret_cast<int>(get(key)); }
+	String *get_string(const Key& key) { return static_cast<String *>(get(key)); }
+
+protected:
+
+	// the pool I'm allocated on
+	Pool& pool;
+
 private:
-	friend Pool;
 
 	// expand when these %% of size exausted
 	enum {
 		THRESHOLD_PERCENT=75
 	};
 
-	// the pool I'm allocated on
-	Pool *pool;
+	// am I thread-safe?
+	bool thread_safe;
 
 	// the index of [size] in [sizes]
 	int size_index;
@@ -59,41 +83,25 @@ private:
 		Value *value;
 		Pair *link;
 		
-		void *operator new(size_t size, Pool *apool);
+		void *operator new(size_t size, Pool& apool);
 
-		Pair(uint acode, Key& akey, Value *avalue, Pair *alink) :
+		Pair(uint acode, const Key& akey, Value *avalue, Pair *alink) :
 			code(acode),
 			key(akey),
 			value(avalue),
 			link(alink) {}
 	} **refs;
 
-	// new&constructors made private to enforce factory manufacturing at pool
-	void *operator new(size_t size, Pool *apool);
-
-	Hash(Pool *apool);
-
 	// filled to threshold: needs expanding
 	bool full() { return used==threshold; }
 
 	// allocate larger buffer & rehash
 	void expand();
 
-public:
-
-	// useful generic hash function
-	static uint generic_code(uint aresult, char *start, uint size);
-
-	// put a [value] under the [key]
-	void put(Key& key, Value *value);
-
-	// get associated [value] by the [key]
-	Value* get(Key& key);
-
 private: //disabled
 
-	Hash& operator = (Hash& src) { return *this; }
-	Hash(Hash& src) {}
+	//Hash(Hash&) {}
+	Hash& operator = (const Hash&) { return *this; }
 };
 
 #endif