--- parser3/src/include/pa_hash.h	2001/04/05 16:30:41	1.35
+++ parser3/src/include/pa_hash.h	2001/05/17 10:22:24	1.41
@@ -5,14 +5,13 @@
 
 	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
 
-	$Id: pa_hash.h,v 1.35 2001/04/05 16:30:41 paf Exp $
+	$Id: pa_hash.h,v 1.41 2001/05/17 10:22:24 parser Exp $
 */
 
 #ifndef PA_HASH_H
 #define PA_HASH_H
 
-#include <stddef.h>
-
+#include "pa_config_includes.h"
 #include "pa_pool.h"
 #include "pa_types.h"
 #include "pa_string.h"
@@ -32,6 +31,9 @@ public:
 	/// for_each iterator function type
 	typedef void (*For_each_func)(const Key& key, Val *value, void *info);
 
+	/// first_that iterator function type
+	typedef bool (*First_that_func)(const Key& key, Val *value, void *info);
+
 public:
 
 	Hash(Pool& apool) : Pooled(apool) { 
@@ -42,27 +44,29 @@ public:
 	static uint generic_code(uint aresult, const char *start, uint allocated);
 
 	/// put a [value] under the [key], return existed or not
-	/*SYNCHRONIZED*/ bool put(const Key& key, Val *value);
+	bool put(const Key& key, Val *value);
 /*
 	/// dirty hack to allow constant items storage. I long for Hash<const Val*>
-	/*SYNCHRONIZED* / bool put(const Key& key, const Val *value) {
+	bool put(const Key& key, const Val *value) {
 		return put(key, const_cast<Val *>(value)); 
 	}
 */
 	/// get associated [value] by the [key]
-	/*SYNCHRONIZED*/ Val *get(const Key& key) const;
+	Val *get(const Key& key) const;
 
 	/// put a [value] under the [key] if that [key] existed, return existed or not
-	/*SYNCHRONIZED*/ bool put_replace(const Key& key, Val *value);
+	bool put_replace(const Key& key, Val *value);
 
 	/// put a [value] under the [key] if that [key] NOT existed, return existed or not
-	/*SYNCHRONIZED*/ bool put_dont_replace(const Key& key, Val *value);
+	bool put_dont_replace(const Key& key, Val *value);
 
 	/// put all 'src' values if NO with same key existed
-	/*SYNCHRONIZED*/ void merge_dont_replace(const Hash& src);
+	void merge_dont_replace(const Hash& src);
 
 	void put(const Key& key, int     value) { put(key, reinterpret_cast<Val *>(value)); }
-	void put(const Key& key, String *value) { put(key, static_cast<Val *>(value)); }
+	void put(const Key& key, const String *value) { 
+		put(key, static_cast<Val *>(const_cast<String *>(value))); 
+	}
 
 	//@{
 	/// handy get, longing for Hash<int>, Hash<String *>
@@ -71,10 +75,13 @@ public:
 	//@}
 
 	/// number of elements in hash
-	int size() { return used; }
+	int size() const { return used; }
 
 	/// iterate over all not zero elements
-	void for_each(For_each_func func, void *info=0);
+	void for_each(For_each_func func, void *info=0) const;
+
+	/// iterate over all elements until condition
+	Val* first_that(First_that_func func, void *info=0) const;
 
 	/// remove all elements
 	void clear();
@@ -85,28 +92,28 @@ protected:
 
 private:
 
-	// expand when these %% of allocated exausted
+	/// expand when these %% of allocated exausted
 	enum {
 		THRESHOLD_PERCENT=75
 	};
 
-	// the index of [allocated] in [allocates]
+	/// the index of [allocated] in [allocates]
 	int allocates_index;
 
-	// possible [allocates]. prime numbers
+	/// possible [allocates]. prime numbers
 	static uint allocates[];
 	static int allocates_count;
 
-	// number of allocated pairs
+	/// number of allocated pairs
 	int allocated;
 
-	// helper: expanding when used == threshold
+	/// helper: expanding when used == threshold
 	int threshold;
 
-	// used pairs
+	/// used pairs
 	int used;
 
-	// main storage
+	/// pair storage
 	class Pair {
 		friend Hash;
 
@@ -124,10 +131,10 @@ private:
 			link(alink) {}
 	} **refs;
 
-	// filled to threshold: needs expanding
+	/// filled to threshold: needs expanding
 	bool full() { return used==threshold; }
 
-	// allocate larger buffer & rehash
+	/// allocate larger buffer & rehash
 	void expand();
 
 private: //disabled