--- parser3/src/classes/hashfile.C	2001/10/22 16:44:42	1.2
+++ parser3/src/classes/hashfile.C	2003/11/06 08:22:48	1.24
@@ -1,79 +1,125 @@
 /** @file
 	Parser: @b hashfile parser class.
 
-	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
-
-	$Id: hashfile.C,v 1.2 2001/10/22 16:44:42 parser Exp $
+	Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
+	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-#include "pa_config_includes.h"
-#ifdef HAVE_LIBDB
+
+static const char* IDENT="$Id: hashfile.C,v 1.24 2003/11/06 08:22:48 paf Exp $";
 
 #include "classes.h"
+
 #include "pa_request.h"
+#include "pa_vmethod_frame.h"
 #include "pa_vhashfile.h"
 #include "pa_vhash.h"
 
-// defines
-
-#define HASH_CLASS_NAME "hashfile"
-
 // class
 
 class MHashfile : public Methoded {
 public: // VStateless_class
-	Value *create_new_value(Pool& pool) { return new(pool) VHashfile(pool); }
+	Value *create_new_value() { return new VHashfile; }
 
 public:
-	MHashfile(Pool& pool);
+	MHashfile();
 public: // Methoded
 	bool used_directly() { return true; }
 };
 
+// global variable
+
+DECLARE_CLASS_VAR(hashfile, new MHashfile, 0);
+
 // methods
 
-static void _assign(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VHashfile& self=*static_cast<VHashfile *>(r.self);
+static void _open(Request& r, MethodParams& params) {
+	VHashfile& self=GET_SELF(r, VHashfile);
 	
-	const String &sfile_spec=params->as_string(0, "filename must be string");
-
-	self.assign(r.absolute(sfile_spec), method_name);
+	self.open(r.absolute(params.as_string(0, "filename must be string")));
 }
-//static_cast<VHashfile *>(r.self)	const String& file_spec=->file_spec();
-
-// constructor
 
-MHashfile::MHashfile(Pool& apool) : Methoded(apool) {
-	set_name(*NEW String(pool(), HASH_CLASS_NAME));
-
-	// ^hashfile::assign[filename]
-	add_native_method("assign", Method::CT_DYNAMIC, _assign, 1, 1);
-/*
-	// ^hashfile.delete[key]
-	add_native_method("delete", Method::CT_DYNAMIC, _delete, 1, 1);
-	// ^hashfile.clear[]
-	add_native_method("clear", Method::CT_DYNAMIC, _clear, 0, 0);
-	// ^cache[key](seconds){code}
-	add_native_method("cache", Method::CT_DYNAMIC, _cache, 3, 3);
-	// ^cancel[]
-	add_native_method("cancel", Method::CT_DYNAMIC, _cancel, 0, 0);
-	// ^lock{code}
-	add_native_method("lock", Method::CT_DYNAMIC, _lock, 1, 1);
-	// ^pack[]
-	add_native_method("pack", Method::CT_DYNAMIC, _pack, 0, 0);
-	*/
+#if LATER
+static void _hash(Request& r, MethodParams& params) {
+	VHashfile& self=GET_SELF(r, VHashfile);
+	
+	// write out result
+	VHash& result=*new(pool) VHash(pool, *self.get_hash(&method_name));
+	result.set_name(method_name);
+	r.write_no_lang(result);
 }
 
-// global variable
-
-Methoded *hashfile_base_class;
+static void _delete(Request& r, MethodParams& params) {
+	VHashfile& self=GET_SELF(r, VHashfile);
+	
+	if(params.size()==0)
+		self.mark_to_cancel_cache();
+	else {
+		// key
+		const String &key=params.as_string(0, "key must be string");
+		// remove
+		self.get_table_ptr(&method_name)->remove(key);
+	}
+}
 
-// creator
+#endif
+static void _clear(Request& r, MethodParams&) {
+	VHashfile& self=GET_SELF(r, VHashfile);
+	self.clear();
+}
 
-Methoded *MHashfile_create(Pool& pool) {
-	return hashfile_base_class=new(pool) MHashfile(pool);
+#if LATER
+static void _foreach(Request& r, MethodParams& params) {
+	VHashfile& self=GET_SELF(r, VHashfile);
+
+	const String& key_var_name=params.as_string(0, "key-var name must be string");
+	const String& value_var_name=params.as_string(1, "value-var name must be string");
+	Value& body_code=params.as_junction(2, "body must be code");
+	Value *delim_maybe_code=params.size()>3?&params.get(3):0;
+
+	bool need_delim=false;
+	Value& var_context=*body_code.get_junction()->wcontext;
+	VString& vkey=*new(pool) VString(pool);
+	VString& vvalue=*new(pool) VString(pool);
+
+	DB_Cursor cursor(*self.get_table_ptr(&method_name), &method_name);
+	while(true) {
+		String *key;
+		String *data;
+		if(!cursor.get(pool, key, data, DB_NEXT))
+			break;
+
+		if(!key) 
+			continue; // expired
+
+		vkey.set_string(*key);
+		vvalue.set_string(*data);
+		var_context.put_element(key_var_name, &vkey);
+		var_context.put_element(value_var_name, &vvalue);
+
+		Value& processed_body=r.process(body_code);
+		if(delim_maybe_code) { // delimiter set?
+			const String *string=processed_body.get_string();
+			if(need_delim && string && string->size()) // need delim & iteration produced string?
+				r.write_pass_lang(r.process(*delim_maybe_code));
+			need_delim=true;
+		}
+		r.write_pass_lang(processed_body);
+	}
 }
 
 #endif
+// constructor
+
+MHashfile::MHashfile(): Methoded("hashfile") {
+	// ^hashfile::open[db_home;filename]
+	add_native_method("open", Method::CT_DYNAMIC, _open, 1, 1);
+	// ^hash[]
+//	add_native_method("hash", Method::CT_DYNAMIC, _hash, 0, 0);
+	// ^hashfile.delete[key]
+//	add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);
+	// ^hashfile.clear[]
+	add_native_method("clear", Method::CT_DYNAMIC, _clear, 0, 0);
+	// ^hashfile.foreach[key;value]{code}[delim]
+//	add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2+1, 2+1+1);
+}