--- parser3/src/include/pa_hash.h	2001/03/18 11:37:50	1.25
+++ parser3/src/include/pa_hash.h	2001/03/24 10:54:45	1.31
@@ -1,9 +1,11 @@
-/*
-	Parser
+/** @file
+	Parser: hash class decl.
+
 	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
+
 	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
 
-	$Id: pa_hash.h,v 1.25 2001/03/18 11:37:50 paf Exp $
+	$Id: pa_hash.h,v 1.31 2001/03/24 10:54:45 paf Exp $
 */
 
 #ifndef PA_HASH_H
@@ -15,13 +17,23 @@
 #include "pa_types.h"
 #include "pa_string.h"
 
+
+/** 
+	Pooled hash.
+
+	Automatically rehashed when almost full.
+
+	The only object that can be thread safe, wich is specified in constructor,
+	default 'not safe'.
+*/
 class Hash : public Pooled {
 public:
 
-	typedef String Key;
-	typedef void Value;
+	typedef String Key; ///< hash Key type. longing for templates
+	typedef void Val; ///< hash Val type. longing for templates
 
-	typedef void (*Foreach_func)(void *info, const Key& key, Value *value);
+	/// for_each iterator function type
+	typedef void (*For_each_func)(const Key& key, Val *value, void *info);
 
 public:
 
@@ -29,33 +41,41 @@ public:
 		construct(apool, athread_safe); 
 	}
 
-	// useful generic hash function
+	/// useful generic hash function
 	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, Value *value);
+	/// put a [value] under the [key], return existed or not
+	/*SYNCHRONIZED*/ bool put(const Key& key, Val *value);
 
-	// get associated [value] by the [key]
-	/*SYNCHRONIZED*/ Value *get(const Key& key) const;
+	/// get associated [value] by the [key]
+	/*SYNCHRONIZED*/ 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, Value *value);
+	/// put a [value] under the [key] if that [key] existed, return existed or not
+	/*SYNCHRONIZED*/ 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, Value *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);
 
-	// put all 'src' values if NO with same key existed
+	/// put all 'src' values if NO with same key existed
 	/*SYNCHRONIZED*/ void merge_dont_replace(const Hash& src);
 
-	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)); }
+	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)); }
 
+	//@{
+	/// handy get, longing for Hash<int>, Hash<String *>
 	int get_int(const Key& key) { return reinterpret_cast<int>(get(key)); }
 	const String *get_string(const Key& key) { return static_cast<String *>(get(key)); }
+	//@}
 
+	/// number of elements in hash
 	int size() { return used; }
 
-	void foreach(Foreach_func func, void *info);
+	/// iterate over all not zero elements
+	void for_each(For_each_func func, void *info=0);
+
+	/// remove all elements
+	void clear();
 
 protected:
 
@@ -93,12 +113,12 @@ private:
 
 		uint code;
 		const Key key;
-		Value *value;
+		Val *value;
 		Pair *link;
 		
 		void *operator new(size_t allocated, Pool& apool);
 
-		Pair(uint acode, const Key& akey, Value *avalue, Pair *alink) :
+		Pair(uint acode, const Key& akey, Val *avalue, Pair *alink) :
 			code(acode),
 			key(akey),
 			value(avalue),