--- parser3/src/classes/hashfile.C 2001/10/24 10:49:47 1.7 +++ parser3/src/classes/hashfile.C 2005/08/08 09:24:27 1.35 @@ -1,181 +1,150 @@ /** @file Parser: @b hashfile parser class. - Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com) - Author: Alexander Petrosyan (http://design.ru/paf) - - $Id: hashfile.C,v 1.7 2001/10/24 10:49:47 parser Exp $ + Copyright (c) 2001-2004 ArtLebedev Group (http://www.artlebedev.com) + Author: Alexandr Petrosian (http://paf.design.ru) */ -#include "pa_config_includes.h" + +static const char * const IDENT="$Id: hashfile.C,v 1.35 2005/08/08 09:24:27 paf Exp $"; + #include "classes.h" -#ifdef HAVE_LIBDB #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(Pool& apool, HashStringValue&) { return new VHashfile(apool); } public: - MHashfile(Pool& pool); + MHashfile(); public: // Methoded bool used_directly() { return true; } }; -// methods +// global variable -static void _open(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - VHashfile& self=*static_cast(r.self); - - // file_spec - const String &file_spec=params->as_string(0, "filename must be string"); +DECLARE_CLASS_VAR(hashfile, new MHashfile, 0); - self.set_connection( - DB_manager->get_connection( - r.absolute(file_spec), - method_name) - ); -} +// defines for statics +#define OPEN_DATA_NAME "HASHFILE-OPEN-DATA" -static void _transaction(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - VHashfile& self=*static_cast(r.self); - - // body code - Value& body_code=params->as_junction(0, "body must be code"); - - // connection - DB_Connection& connection=self.get_connection(&method_name); +// methods - // transaction - Auto_transaction transaction(connection); +typedef Hash HashStringBool; - // execute body - try { - r.write_assign_lang(r.process(body_code)); - } catch(...) { // process/commit problem - transaction.mark_to_rollback(); - - /*re*/throw; +static void _open(Request& r, MethodParams& params) { + HashStringBool* file_list=static_cast(r.classes_conf.get(OPEN_DATA_NAME)); + if(!file_list) { + file_list=new HashStringBool(); + r.classes_conf.put(OPEN_DATA_NAME, file_list); } -} - -static void remove(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - VHashfile& self=*static_cast(r.self); - - // key - const String &key=params->as_string(0, "key must be string"); - // connection - DB_Connection& connection=self.get_connection(&method_name); + const String& file_spec=r.absolute(params.as_string(0, "filename must be string")); + if(file_list->get(file_spec)) + throw Exception("parser.runtime", + 0, + "this hashfile is already opened, use existing variable"); + file_list->put(file_spec, true); - connection.remove(key); + VHashfile& self=GET_SELF(r, VHashfile); + self.open(file_spec); } -static void _clear(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - - // file_spec - const String &file_spec=params->as_string(0, "filename must be string"); - - DB_manager->clear_dbfile(r.absolute(file_spec)); -} - -static void _hash(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - VHashfile& self=*static_cast(r.self); +static void _hash(Request& r, MethodParams&) { + 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); + VHash& result=*new VHash(*self.get_hash()); r.write_no_lang(result); } -static void _cache(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - VHashfile& self=*static_cast(r.self); +static void _delete(Request& r, MethodParams& params) { + VHashfile& self=GET_SELF(r, VHashfile); - // key, expires, body code - const String &key=params->as_string(0, "key must be string"); - double expires=params->as_double(1, "expires must be number", r); - Value& body_code=params->as_junction(2, "body must be code"); - - // connection - DB_Connection& connection=self.get_connection(&method_name); - - // transaction - Auto_transaction transaction(connection); - - // execute body - try { - if(expires) { // 'expires' specified? try cached copy... - if(String *cached_body=connection.get(key)) { // have cached copy? - r.write_assign_lang(*cached_body); - // happy with it - return; - } - } else // 'expires'=0, forget cached copy - connection.remove(key); - - // process - Value& processed_body=r.process(body_code); - r.write_assign_lang(processed_body); - - // put it to cache if 'expires' specified - if(expires) - connection.put(key, processed_body.as_string(), time(0)+(time_t)expires); - } catch(...) { // process/commit problem - transaction.mark_to_rollback(); - - /*re*/throw; + if(!params.count()) { + // ^hashfile.delete[] asked to delete hashfile itself + self.delete_files(); + return; + } + // key + const String &key=params.as_string(0, "key must be string"); + // remove + self.remove(key); +} + +static void _clear(Request& r, MethodParams&) { + VHashfile& self=GET_SELF(r, VHashfile); + self.clear(); +} + +#ifndef DOXYGEN +struct Foreach_info { + Request* r; + const String* key_var_name; + const String* value_var_name; + Value* body_code; + Value* delim_maybe_code; + + Value* var_context; + VString* vkey; + VString* vvalue; + bool need_delim; +}; +#endif +static void one_foreach_cycle(const String::Body key, const String& value, void* ainfo) { + Foreach_info& info=*static_cast(ainfo); + info.vkey->set_string(*new String(key, String::L_TAINTED)); + info.vvalue->set_string(value); + info.var_context->put_element(*info.var_context, *info.key_var_name, info.vkey, false); + info.var_context->put_element(*info.var_context, *info.value_var_name, info.vvalue, false); + + StringOrValue sv_processed=info.r->process(*info.body_code); + const String* s_processed=sv_processed.get_string(); + if(info.delim_maybe_code && s_processed && s_processed->length()) { // delimiter set and we have body + if(info.need_delim) // need delim & iteration produced string? + info.r->write_pass_lang(info.r->process(*info.delim_maybe_code)); + info.need_delim=true; } + info.r->write_pass_lang(sv_processed); } +static void _foreach(Request& r, MethodParams& params) { + VHashfile& self=GET_SELF(r, VHashfile); -// constructor - -MHashfile::MHashfile(Pool& apool) : Methoded(apool) { - set_name(*NEW String(pool(), HASH_CLASS_NAME)); - - // ^hashfile::open[filename] - add_native_method("open", Method::CT_DYNAMIC, _open, 1, 1); - // ^transaction{code} - add_native_method("transaction", Method::CT_DYNAMIC, _transaction, 1, 1); - // ^hashfile.delete[key] - add_native_method("delete", Method::CT_DYNAMIC, remove, 1, 1); - // ^hashfile:clear[filename] - add_native_method("clear", Method::CT_STATIC, _clear, 1, 1); - // ^hash[] - add_native_method("hash", Method::CT_DYNAMIC, _hash, 0, 0); - // ^cache[key](seconds){code} - add_native_method("cache", Method::CT_DYNAMIC, _cache, 3, 3); -} + Foreach_info info; + + info.r=&r; + info.key_var_name=¶ms.as_string(0, "key-var name must be string"); + info.value_var_name=¶ms.as_string(1, "value-var name must be string"); + info.body_code=¶ms.as_junction(2, "body must be code"); + info.delim_maybe_code=params.count()>3?params.get(3):0; -// global variable + info.var_context=info.body_code->get_junction()->wcontext; + info.vkey=new VString; + info.vvalue=new VString; -Methoded *hashfile_base_class; + info.need_delim=false; -#endif + self.for_each(one_foreach_cycle, &info); +} -// creator +// constructor -Methoded *MHashfile_create(Pool& pool) { - return -#ifdef HAVE_LIBDB - hashfile_base_class=new(pool) MHashfile(pool) -#else - 0 -#endif - ; +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); }