parser3/src/classes/hash.C - diff

Return to hash.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/hash.C between versions 1.129 and 1.164

version 1.129, 2016/07/14 17:06:30	version 1.164, 2024/09/28 19:42:41
Line 1	Line 1
/** @file	/** @file
Parser: @b hash parser class.	Parser: @b hash parser class.

Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

#include "classes.h"	#include "classes.h"
Line 37 DECLARE_CLASS_VAR(hash, new MHash);	Line 37 DECLARE_CLASS_VAR(hash, new MHash);

#ifndef DOXYGEN	#ifndef DOXYGEN
class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {	class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {
const String& statement_string; const char* statement_cstr;
bool distinct;	bool distinct;
HashStringValue& rows_hash;	HashStringValue& result;
Value* row_value;	Value* row_value;
int column_index;	int column_index;
ArrayString& columns;	ArrayString* columns;
bool one_bool_column;	bool one_bool_column;
static VBool only_one_column_value;
Table2hash_value_type value_type;	Table2hash_value_type value_type;
int columns_count;	int columns_count;
public:	public:
Table* empty;	Table* empty;
public:	public:
Hash_sql_event_handlers(	Hash_sql_event_handlers(bool adistinct, HashStringValue& aresult, Table2hash_value_type avalue_type):
const String& astatement_string,
const char* astatement_cstr,
bool adistinct,
HashStringValue& arows_hash,
Table2hash_value_type avalue_type)
:
statement_string(astatement_string),
statement_cstr(astatement_cstr),
distinct(adistinct),	distinct(adistinct),
rows_hash(arows_hash),	result(aresult),
value_type(avalue_type),
row_value(0),	row_value(0),
column_index(0),	column_index(0),
	columns(new ArrayString),
one_bool_column(false),	one_bool_column(false),
columns(*new ArrayString),	value_type(avalue_type),
empty(0) {	empty(0) {
}	}

bool add_column(SQL_Error& error, const char* str, size_t ) {	bool add_column(SQL_Error& error, const char* str, size_t ) {
try {	try {
columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */);	if(columns_count){
	// another query in multi_statements mode
	columns=new ArrayString;
	columns_count=0;
	}
	columns+=new String(str, String::L_TAINTED / no length as 0x00 can be inside */);
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Hash_sql_event_handlers::add_column");	error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column");
return true;	return true;
}	}
}	}

bool before_rows(SQL_Error& error) {	bool before_rows(SQL_Error& error) {
if(columns.count()<1) {	columns_count=columns->count();
error=SQL_Error(PARSER_RUNTIME, "no columns");	if(columns_count<1) {
	error=SQL_Error("no columns");
return true;	return true;
}	}
switch(value_type){	if(columns_count==1) {
case C_STRING: {	one_bool_column=true;
if(columns.count()>2){	} else {
error=SQL_Error(PARSER_RUNTIME, "only 2 columns allowed for $.type[string].");	switch(value_type){
return true;	case C_STRING: {
	if(columns_count>2){
	error=SQL_Error("only 2 columns allowed for $.type[string]");
	return true;
	}
	break;
	}
	case C_TABLE: {
	// create empty table which we'll copy later
	empty=new Table(columns);
	break;
}	}
}
case C_TABLE: {
// create empty table which we'll copy later
empty=new Table(&columns);
columns_count=columns.count();
}
case C_HASH: {
one_bool_column=columns.count()==1;
}	}
}	}
return false;	return false;
Line 110 public:	Line 108 public:

bool add_row_cell(SQL_Error& error, const char *str, size_t ) {	bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
try {	try {
const String& cell=str?new String(str, String::L_TAINTED / no length as 0x00 can be inside */):String::Empty;	const String& cell=str ? new String(str, String::L_TAINTED / no length as 0x00 can be inside */) : String::Empty;

	if(column_index==columns_count){
	// should never happen, buggy driver case
	error=SQL_Error("columns index exceed the columns count");
	return true;
	}

bool duplicate=false;	bool duplicate=false;
if(one_bool_column) {	if(one_bool_column) {
duplicate=rows_hash.put_dont_replace(cell, &only_one_column_value); // put. existed?	duplicate=result.put_dont_replace(cell, &VBool::get(true)); // put. existed?
} else if(column_index==0) {	} else if(column_index==0) {
switch(value_type){	switch(value_type){
case C_HASH: {	case C_HASH: {
VHash* row_vhash=new VHash;	VHash* row_vhash=new VHash;
row_value=row_vhash;	row_value=row_vhash;
duplicate=rows_hash.put_dont_replace(cell, row_vhash); // put. existed?	duplicate=result.put_dont_replace(cell, row_vhash); // put. existed?
break;	break;
}	}
case C_STRING: {	case C_STRING: {
VString* row_vstring=new VString();	VString* row_vstring=new VString();
row_value=row_vstring;	row_value=row_vstring;
duplicate=rows_hash.put_dont_replace(cell, row_vstring); // put. existed?	duplicate=result.put_dont_replace(cell, row_vstring); // put. existed?
break;	break;
}	}
case C_TABLE: {	case C_TABLE: {
VTable* vtable=(VTable*)rows_hash.get(cell);	VTable* vtable=(VTable*)result.get(cell);
Table* table;

if(vtable) { // table with this key exist?	if(vtable) { // table with this key exist?
if(!distinct) {	if(!distinct) {
duplicate=true;	duplicate=true;
break;	break;
}	}
table=vtable->get_table();
} else {	} else {
// no? creating table of same structure as source	// no? creating table of same structure as source
Table::Action_options table_options(0, 0);	Table::Action_options table_options(0, 0);
table=new Table(empty, table_options/no rows, just structure*/);	vtable=new VTable(new Table(empty, table_options/no rows, just structure*/));
vtable=new VTable(table);	result.put(cell, vtable); // put
rows_hash.put(cell, vtable); // put
}	}
ArrayString* row=new ArrayString(columns_count);	ArrayString* row=new ArrayString(columns_count);
row_value=(Value*)row;	row_value=(Value*)row;
*row+=&cell;	*row+=&cell;
*table+=row;	*vtable->get_table()+=row;
break;	break;
}	}
}	}
} else {	} else {
switch(value_type) {	switch(value_type) {
case C_HASH: {	case C_HASH: {
row_value->get_hash()->put(*columns[column_index], new VString(cell));	row_value->get_hash()->put(*columns->get(column_index), new VString(cell));
break;	break;
}	}
case C_STRING: {	case C_STRING: {
Line 173 public:	Line 174 public:
}	}

if(duplicate & !distinct) {	if(duplicate & !distinct) {
error=SQL_Error(PARSER_RUNTIME, "duplicate key");	error=SQL_Error("duplicate key");
return true;	return true;
}	}

column_index++;	column_index++;
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Hash_sql_event_handlers::add_row_cell");	error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell");
return true;	return true;
}	}
}	}

};	};
VBool Hash_sql_event_handlers::only_one_column_value(true);

#endif	#endif

static void _create_or_add(Request& r, MethodParams& params) {	static void _create_or_add(Request& r, MethodParams& params) {
if(params.count()) {	if(params.count()) {
Value& vsrc=params.as_no_junction(0, PARAM_MUST_BE_HASH);	Value& vsrc=params.as_no_junction(0, PARAM_MUST_BE_HASH);
VHash& self=GET_SELF(r, VHash);	VHashBase& self=GET_SELF(r, VHashBase);
HashStringValue* src_hash;
HashStringValue* self_hash=&(self.hash());	HashStringValue* self_hash=&(self.hash());
	HashStringValue* src_hash;

if(VHash* src=static_cast<VHash*>(vsrc.as(VHASH_TYPE))) {	if(VHashBase* src=dynamic_cast<VHashBase*>(&vsrc)) {
src_hash=&(src->hash());	src_hash=&(src->hash());

if(src_hash==self_hash) // same: doing nothing	if(src_hash==self_hash) // same: doing nothing
Line 210 static void _create_or_add(Request& r, M	Line 210 static void _create_or_add(Request& r, M
}	}

if(src_hash)	if(src_hash)
src_hash->for_each<HashStringValue*>(copy_all_overwrite_to, self_hash);	for(HashStringValue::Iterator i(*src_hash); i; i.next())
	self_hash->put(i.key(), i.value());
}	}
}	}

static void _sub(Request& r, MethodParams& params) {	static void _sub(Request& r, MethodParams& params) {
if(HashStringValue* src=params.as_hash(0, "param")) {	if(HashStringValue* src=params.as_hash(0, "param")) {
HashStringValue* self=&(GET_SELF(r, VHash).hash());	HashStringValue* self=&(GET_SELF(r, VHashBase).hash());
if(src==self) { // same: clearing	if(src==self) { // same: clearing
self->clear();	self->clear();
return;	return;
}	}
src->for_each<HashStringValue*>(remove_key_from, self);	for(HashStringValue::Iterator i(*src); i; i.next())
	self->remove(i.key());
}	}
}	}

static void copy_all_dontoverwrite_to(	static void copy_all_dontoverwrite_to(HashStringValue::key_type key, HashStringValue::value_type value, HashStringValue* dest) {
HashStringValue::key_type key,
HashStringValue::value_type value,
HashStringValue* dest) {
dest->put_dont_replace(key, value);	dest->put_dont_replace(key, value);
}	}
static void _union(Request& r, MethodParams& params) {	static void _union(Request& r, MethodParams& params) {
// dest = copy of self	// dest = copy of self
Value& result=*new VHash(GET_SELF(r, VHash).hash());	Value& result=*new VHash(GET_SELF(r, VHashBase).hash());
// dest += b	// dest += b
if(HashStringValue* src=params.as_hash(0, "param"))	if(HashStringValue* src=params.as_hash(0, "param"))
src->for_each<HashStringValue*>(copy_all_dontoverwrite_to, result.get_hash());	src->for_each<HashStringValue*>(copy_all_dontoverwrite_to, result.get_hash());

// return result	// return result
r.write_no_lang(result);	r.write(result);
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
Line 248 struct Copy_intersection_to_info {	Line 247 struct Copy_intersection_to_info {
HashStringValue* dest;	HashStringValue* dest;
};	};
#endif	#endif
static void copy_intersection_to(
HashStringValue::key_type key,	static void copy_intersection_by_arg(HashStringValue::key_type key, HashStringValue::value_type, Copy_intersection_to_info *info) {
HashStringValue::value_type value,	if(HashStringValue::value_type value=info->b->get(key))
Copy_intersection_to_info *info) {	info->dest->put_dont_replace(key, value);
	}

	static void copy_intersection_by_self(HashStringValue::key_type key, HashStringValue::value_type value, Copy_intersection_to_info *info) {
if(info->b->get(key))	if(info->b->get(key))
info->dest->put_dont_replace(key, value);	info->dest->put_dont_replace(key, value);
}	}

static void _intersection(Request& r, MethodParams& params) {	static void _intersection(Request& r, MethodParams& params) {
Value& result=*new VHash;	Value& result=*new VHash;
// dest += b
	bool order_by_arg=false;
	if(params.count()>1)
	if(HashStringValue* options=params.as_hash(1, "options")) {
	int valid_options=0;
	if(Value* vorder=options->get("order")) {
	const String &sorder=r.process(*vorder).as_string();
	if(sorder == "arg")
	order_by_arg=true;
	else if(sorder != "self")
	throw Exception(PARSER_RUNTIME, &sorder, "'order' must be 'self' or 'arg'");
	valid_options++;
	}
	if(valid_options!=options->count())
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
	}

if(HashStringValue* b=params.as_hash(0, "param")) {	if(HashStringValue* b=params.as_hash(0, "param")) {
Copy_intersection_to_info info={b, result.get_hash()};	if(order_by_arg){
GET_SELF(r, VHash).hash().for_each<Copy_intersection_to_info*>(copy_intersection_to, &info);	Copy_intersection_to_info info={&GET_SELF(r, VHashBase).hash(), result.get_hash()};
	b->for_each<Copy_intersection_to_info*>(copy_intersection_by_arg, &info);
	} else {
	Copy_intersection_to_info info={b, result.get_hash()};
	GET_SELF(r, VHashBase).hash().for_each<Copy_intersection_to_info*>(copy_intersection_by_self, &info);
	}
}	}

// return result	r.write(result);
r.write_no_lang(result);
}	}

static bool intersects(	static bool intersects( HashStringValue::key_type key, HashStringValue::value_type /value/, HashStringValue* b) {
HashStringValue::key_type key,
HashStringValue::value_type /value/,
HashStringValue* b) {
return b->get(key)!=0;	return b->get(key)!=0;
}	}

Line 278 static void _intersects(Request& r, Meth	Line 298 static void _intersects(Request& r, Meth
bool result=false;	bool result=false;

if(HashStringValue* b=params.as_hash(0, "param")) {	if(HashStringValue* b=params.as_hash(0, "param")) {
HashStringValue* self=&(GET_SELF(r, VHash).hash());	HashStringValue* self=&(GET_SELF(r, VHashBase).hash());
if(b==self) {	if(b==self) {
r.write_no_lang(VBool::get(true));	r.write(VBool::get(true));
return;	return;
}	}
result=self->first_that<HashStringValue*>(intersects, b)!=0;	result=self->first_that<HashStringValue*>(intersects, b)!=0;
}	}

// return result	// return result
r.write_no_lang(VBool::get(result));	r.write(VBool::get(result));
}	}


extern String sql_bind_name;
extern String sql_limit_name;
extern String sql_offset_name;
extern String sql_default_name;
extern String sql_distinct_name;
extern String sql_value_type_name;
extern Table2hash_value_type get_value_type(Value& vvalue_type);	extern Table2hash_value_type get_value_type(Value& vvalue_type);
extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);	extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);	extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
Line 312 static void _sql(Request& r, MethodParam	Line 326 static void _sql(Request& r, MethodParam
if(params.count()>1)	if(params.count()>1)
if(HashStringValue* options=params.as_hash(1, "sql options")) {	if(HashStringValue* options=params.as_hash(1, "sql options")) {
int valid_options=0;	int valid_options=0;
if(Value* vbind=options->get(sql_bind_name)) {	for(HashStringValue::Iterator i(*options); i; i.next() ){
valid_options++;	String::Body key=i.key();
bind=vbind->get_hash();	Value* value=i.value();
}	if(key == sql_bind_name) {
if(Value* vlimit=options->get(sql_limit_name)) {	bind=value->get_hash();
valid_options++;	valid_options++;
limit=(ulong)r.process_to_value(*vlimit).as_double();	} else if(key == sql_limit_name) {
}	limit=(ulong)r.process(*value).as_double();
if(Value* voffset=options->get(sql_offset_name)) {	valid_options++;
valid_options++;	} else if(key == sql_offset_name) {
offset=(ulong)r.process_to_value(*voffset).as_double();	offset=(ulong)r.process(*value).as_double();
}	valid_options++;
if(Value* vdistinct=options->get(sql_distinct_name)) {	} else if (key == sql_distinct_name) {
valid_options++;	distinct=r.process(*value).as_bool();
distinct=r.process_to_value(*vdistinct).as_bool();	valid_options++;
}	} else if (key == sql_value_type_name) {
if(Value* vvalue_type=options->get(sql_value_type_name)) {	value_type=get_value_type(r.process(*value));
valid_options++;	valid_options++;
value_type=get_value_type(r.process_to_value(*vvalue_type));	}
}	}
if(valid_options!=options->count())	if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
Line 341 static void _sql(Request& r, MethodParam	Line 355 static void _sql(Request& r, MethodParam
if(bind)	if(bind)
placeholders_count=marshal_binds(*bind, placeholders);	placeholders_count=marshal_binds(*bind, placeholders);

Temp_lang temp_lang(r, String::L_SQL);
const String& statement_string=r.process_to_string(statement);	const String& statement_string=r.process_to_string(statement);
const char* statement_cstr=statement_string.untaint_cstr(r.flang, r.connection());	const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());

	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
	hash.clear();
	Hash_sql_event_handlers handlers(distinct, hash, value_type);

HashStringValue& hash=GET_SELF(r, VHash).hash();	r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string);
hash.clear();
Hash_sql_event_handlers handlers(
statement_string, statement_cstr,
distinct,
hash,
value_type);

r.connection()->query(
statement_cstr,
placeholders_count, placeholders,
offset, limit,
handlers,
statement_string);

if(bind)	if(bind)
unmarshal_bind_updates(*bind, placeholders_count, placeholders);	unmarshal_bind_updates(*bind, placeholders_count, placeholders);
}	}

static void keys_collector(	static void keys_collector(HashStringValue::key_type key, HashStringValue::value_type, Table *table) {
HashStringValue::key_type key,
HashStringValue::value_type,
Table *table) {
Table::element_type row(new ArrayString(1));	Table::element_type row(new ArrayString(1));
*row+=new String(key, String::L_TAINTED);	*row+=new String(key, String::L_TAINTED);
*table+=row;	*table+=row;
Line 383 static void _keys(Request& r, MethodPara	Line 384 static void _keys(Request& r, MethodPara
*columns+=keys_column_name;	*columns+=keys_column_name;
Table* table=new Table(columns);	Table* table=new Table(columns);

GET_SELF(r, VHash).hash().for_each<Table*>(keys_collector, table);	GET_SELF(r, VHashBase).hash().for_each<Table*>(keys_collector, table);

r.write_no_lang(*new VTable(table));	r.write(*new VTable(table));
}	}

static void _count(Request& r, MethodParams&) {	static void _count(Request& r, MethodParams&) {
r.write_no_lang(*new VInt(GET_SELF(r, VHash).hash().count()));	r.write(*new VInt(GET_SELF(r, VHashBase).hash().count()));
}	}

static void _delete(Request& r, MethodParams& params) {	static void _delete(Request& r, MethodParams& params) {
if(params.count()>0)	if(params.count()>0)
GET_SELF(r, VHash).hash().remove(params.as_string(0, "key must be string"));	GET_SELF(r, VHashBase).hash().remove(params.as_string(0, "key must be string"));
else	else
GET_SELF(r, VHash).hash().clear();	GET_SELF(r, VHashBase).hash().clear();
}	}

static void _contains(Request& r, MethodParams& params) {	static void _contains(Request& r, MethodParams& params) {
VHash& self=GET_SELF(r, VHash);	VHashBase& self=GET_SELF(r, VHashBase);
const String& key_name=params.as_string(0, "key must be string");	const String& key_name=params.as_string(0, "key must be string");
bool result=SYMBOLS_EQ(key_name,_DEFAULT_SYMBOL) ? (self.get_default() != 0) : self.hash().contains(key_name);	bool result=SYMBOLS_EQ(key_name,_DEFAULT_SYMBOL) ? (self.get_default() != 0) : self.hash().contains(key_name);
r.write_no_lang(VBool::get(result));	r.write(VBool::get(result));
}	}

static void _foreach(Request& r, MethodParams& params) {	static void _foreach(Request& r, MethodParams& params) {
Line 412 static void _foreach(Request& r, MethodP	Line 413 static void _foreach(Request& r, MethodP
const String* key_var_name=&params.as_string(0, "key-var name must be string");	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");	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* body_code=&params.as_junction(2, "body must be code");
Value* delim_maybe_code=params.count()>3?params.get(3):0;	Value* delim_maybe_code=params.count()>3?&params[3]:0;
Value& caller=*r.get_method_frame()->caller();	Value& caller=*r.get_method_frame()->caller();

if(key_var_name->is_empty()) key_var_name=0;	if(key_var_name->is_empty()) key_var_name=0;
if(value_var_name->is_empty()) value_var_name=0;	if(value_var_name->is_empty()) value_var_name=0;

VHash& self=GET_SELF(r, VHash);	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
HashStringValue& hash=self.hash();

if(delim_maybe_code){ // delimiter set	if(delim_maybe_code){ // delimiter set
bool need_delim=false;;	bool need_delim=false;;
Line 432 static void _foreach(Request& r, MethodP	Line 432 static void _foreach(Request& r, MethodP
if(value_var_name)	if(value_var_name)
r.put_element(caller, *value_var_name, i.value());	r.put_element(caller, *value_var_name, i.value());

StringOrValue sv_processed=r.process(*body_code);	Value& sv_processed=r.process(*body_code);
Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);	TempSkip4Delimiter skip(r);

const String* s_processed=sv_processed.get_string();	const String* s_processed=sv_processed.get_string();
if(s_processed && !s_processed->is_empty()) { // we have body	if(s_processed && !s_processed->is_empty()) { // we have body
if(need_delim) // need delim & iteration produced string?	if(need_delim) // need delim & iteration produced string?
r.write_pass_lang(r.process(*delim_maybe_code));	r.write(r.process(*delim_maybe_code));
else	else
need_delim=true;	need_delim=true;
}	}

r.write_pass_lang(sv_processed);	r.write(sv_processed);

if(lskip==Request::SKIP_BREAK)	if(skip.check_break())
break;	break;
}	}
} else {	} else {
Line 459 static void _foreach(Request& r, MethodP	Line 459 static void _foreach(Request& r, MethodP
r.put_element(caller, *value_var_name, i.value());	r.put_element(caller, *value_var_name, i.value());

r.process_write(*body_code);	r.process_write(*body_code);
Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);

if(lskip==Request::SKIP_BREAK)	if(r.check_skip_break())
break;	break;
}	}
}	}
Line 480 inline Value& SingleElementHash(String::	Line 479 inline Value& SingleElementHash(String::
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
struct Hash_seq_item {	struct Hash_seq_item : public PA_Allocated {
HashStringValue::Pair *hash_pair;	HashStringValue::Pair *hash_pair;
union {	union {
const char *c_str;	const char *c_str;
Line 509 static void _sort(Request& r, MethodPara	Line 508 static void _sort(Request& r, MethodPara
const String& key_var_name=params.as_string(0, "key-var name must be string");	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");	const String& value_var_name=params.as_string(1, "value-var name must be string");
Value& key_maker=params.as_junction(2, "key-maker must be code");	Value& key_maker=params.as_junction(2, "key-maker must be code");
bool reverse=params.count()>3/..[desc\|asc\|]/?	bool reverse=params.count()>3 /..[desc\|asc\|]/ && params.as_no_junction(3, "order must not be code").as_string()=="desc"; // default=asc
reverse=params.as_no_junction(3, "order must not be code").as_string()=="desc":
false; // default=asc

const String* key_var=key_var_name.is_empty()? 0 : &key_var_name;	const String* key_var=key_var_name.is_empty()? 0 : &key_var_name;
const String* value_var=value_var_name.is_empty()? 0 : &value_var_name;	const String* value_var=value_var_name.is_empty()? 0 : &value_var_name;
VMethodFrame* context=r.get_method_frame()->caller();	VMethodFrame* context=r.get_method_frame()->caller();

VHash& self=GET_SELF(r, VHash);	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
HashStringValue& hash=self.hash();
int count=hash.count();	int count=hash.count();

Hash_seq_item* seq=new(PointerFreeGC) Hash_seq_item[count];	Hash_seq_item* seq=new Hash_seq_item[count];
int pos=0;	int pos=0;
bool key_values_are_strings=true;	bool key_values_are_strings=true;

Line 531 static void _sort(Request& r, MethodPara	Line 527 static void _sort(Request& r, MethodPara
if(value_var)	if(value_var)
r.put_element(context, value_var, i.value());	r.put_element(context, value_var, i.value());

Value& value=r.process_to_value(key_maker);	Value& value=r.process(key_maker);
if(pos==0) // determining key values type by first one	if(pos==0) // determining key values type by first one
key_values_are_strings=value.is_string();	key_values_are_strings=value.is_string();

Line 546 static void _sort(Request& r, MethodPara	Line 542 static void _sort(Request& r, MethodPara
if(r.charsets.source().NAME()=="KOI8-R" && key_values_are_strings)	if(r.charsets.source().NAME()=="KOI8-R" && key_values_are_strings)
for(pos=0; pos<count; pos++)	for(pos=0; pos<count; pos++)
if(*seq[pos].value.c_str)	if(*seq[pos].value.c_str)
seq[pos].value.c_str=Charset::transcode(seq[pos].value.c_str, r.charsets.source(), UTF8_charset).cstr();	seq[pos].value.c_str=Charset::transcode(seq[pos].value.c_str, r.charsets.source(), pa_UTF8_charset).cstr();

// sort keys	// sort keys
qsort(seq, count, sizeof(Hash_seq_item), key_values_are_strings?sort_cmp_string:sort_cmp_double);	qsort(seq, count, sizeof(Hash_seq_item), key_values_are_strings?sort_cmp_string:sort_cmp_double);
Line 565 static void _sort(Request& r, MethodPara	Line 561 static void _sort(Request& r, MethodPara
}	}

static void _at(Request& r, MethodParams& params) {	static void _at(Request& r, MethodParams& params) {
HashStringValue& hash=GET_SELF(r, VHash).hash();	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
size_t count=hash.count();	size_t count=hash.count();

int pos=0;	int pos=0;

// misha@	// misha@
// I do not like that type is checked before whence.	// I do not like that type is checked before whence.
// But I do not like the idea to move it after whence (where process_to_value can be called) even more.	// But I do not like the idea to move it after whence (where process can be called) even more.
AtResultType result_type=AtResultTypeValue;	AtResultType result_type=AtResultTypeValue;
if(params.count() > 1) {	if(params.count() > 1) {
const String& stype=params.as_string(1, "type must be string");	const String& stype=params.as_string(1, "type must be string");
Line 584 static void _at(Request& r, MethodParams	Line 580 static void _at(Request& r, MethodParams
throw Exception(PARSER_RUNTIME, &stype, "type must be 'key', 'value' or 'hash'");	throw Exception(PARSER_RUNTIME, &stype, "type must be 'key', 'value' or 'hash'");
}	}

Value& vwhence=*params.get(0);	Value& vwhence=params[0];
if(vwhence.is_string()) {	if(vwhence.is_string()) {
const String& swhence=*vwhence.get_string();	const String& swhence=*vwhence.get_string();
if(swhence == "last")	if(swhence == "last")
Line 594 static void _at(Request& r, MethodParams	Line 590 static void _at(Request& r, MethodParams
&swhence,	&swhence,
"whence must be 'first', 'last' or expression");	"whence must be 'first', 'last' or expression");
} else {	} else {
pos=r.process_to_value(vwhence).as_int();	pos=r.process(vwhence).as_int();
if(pos < 0)	if(pos < 0)
pos+=count;	pos+=count;
}	}
Line 605 static void _at(Request& r, MethodParams	Line 601 static void _at(Request& r, MethodParams
{	{
#ifdef HASH_ORDER	#ifdef HASH_ORDER
if(pos == 0) {	if(pos == 0) {
r.write_assign_lang(new VString(new String(hash.first_key(), String::L_TAINTED)));	r.write(new VString(new String(hash.first_key(), String::L_TAINTED)));
} else if((size_t)pos == count-1) {	} else if((size_t)pos == count-1) {
r.write_assign_lang(new VString(new String(hash.last_key(), String::L_TAINTED)));	r.write(new VString(new String(hash.last_key(), String::L_TAINTED)));
} else	} else
#endif	#endif
{	{
for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )	for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )
if(!pos){	if(!pos){
r.write_assign_lang(new VString(new String(i.key(), String::L_TAINTED)));	r.write(new VString(new String(i.key(), String::L_TAINTED)));
break;	break;
}	}
}	}
Line 623 static void _at(Request& r, MethodParams	Line 619 static void _at(Request& r, MethodParams
{	{
#ifdef HASH_ORDER	#ifdef HASH_ORDER
if(pos == 0) {	if(pos == 0) {
r.write_assign_lang(*hash.first_value());	r.write(*hash.first_value());
} else if((size_t)pos == count-1) {	} else if((size_t)pos == count-1) {
r.write_assign_lang(*hash.last_value());	r.write(*hash.last_value());
} else	} else
#endif	#endif
{	{
for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )	for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )
if(!pos){	if(!pos){
r.write_assign_lang(*i.value());	r.write(*i.value());
break;	break;
}	}
}	}
Line 641 static void _at(Request& r, MethodParams	Line 637 static void _at(Request& r, MethodParams
{	{
#ifdef HASH_ORDER	#ifdef HASH_ORDER
if(pos == 0) {	if(pos == 0) {
r.write_no_lang(SingleElementHash(hash.first_key(), hash.first_value()));	r.write(SingleElementHash(hash.first_key(), hash.first_value()));
} else if((size_t)pos == count-1) {	} else if((size_t)pos == count-1) {
r.write_no_lang(SingleElementHash(hash.last_key(), hash.last_value()));	r.write(SingleElementHash(hash.last_key(), hash.last_value()));
} else	} else
#endif	#endif
{	{
for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )	for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )
if(!pos){	if(!pos){
r.write_no_lang(SingleElementHash(i.key(), i.value()));	r.write(SingleElementHash(i.key(), i.value()));
break;	break;
}	}
}	}
Line 659 static void _at(Request& r, MethodParams	Line 655 static void _at(Request& r, MethodParams
}	}
}	}

	extern String table_reverse_name;

	static void _select(Request& r, MethodParams& params) {
	InCycle temp(r);
	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& vcondition=params.as_expression(2, "condition must be number, bool or expression");

	if(key_var_name->is_empty()) key_var_name=0;
	if(value_var_name->is_empty()) value_var_name=0;

	HashStringValue& source_hash=GET_SELF(r, VHashBase).hash();
	Value& caller=*r.get_method_frame()->caller();

	int limit=source_hash.count();
	bool reverse=false;
	bool copy_default=false;

	if(params.count()>3)
	if(HashStringValue* options=params.as_hash(3)) {
	int valid_options=0;
	if(Value* vlimit=options->get(sql_limit_name)) {
	valid_options++;
	limit=r.process(*vlimit).as_int();
	}
	if(Value* vreverse=options->get(table_reverse_name)) {
	valid_options++;
	reverse=r.process(*vreverse).as_bool();
	}
	if(Value* vcopy_default=options->get(sql_default_name)) {
	valid_options++;
	copy_default=r.process(*vcopy_default).as_bool();
	}
	if(valid_options!=options->count())
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
	}

	HashStringValue& result_hash=*new HashStringValue();

	if(limit>0){

	#ifdef HASH_ORDER
	if(reverse){
	for(HashStringValue::ReverseIterator i(source_hash); i; i.prev()){
	if(key_var_name)
	r.put_element(caller, key_var_name, new VString(new String(i.key(), String::L_TAINTED)));
	if(value_var_name)
	r.put_element(caller, *value_var_name, i.value());

	bool condition=r.process(vcondition).as_bool();

	if(r.check_skip_break())
	break;

	if(condition){
	result_hash.put(i.key(), i.value());
	if(!--limit)
	break;
	}
	}
	} else {
	#else
	{
	#endif
	for(HashStringValue::Iterator i(source_hash); i; i.next() ){
	if(key_var_name)
	r.put_element(caller, key_var_name, new VString(new String(i.key(), String::L_TAINTED)));
	if(value_var_name)
	r.put_element(caller, *value_var_name, i.value());

	bool condition=r.process(vcondition).as_bool();

	if(r.check_skip_break())
	break;

	if(condition){
	result_hash.put(i.key(), i.value());
	if(!--limit)
	break;
	}
	}
	}
	}

	VHash *result=new VHash(result_hash);
	if(copy_default){
	result->set_default(GET_SELF(r, VHashBase).get_default());
	}

	r.write(*result);
	}

	static void _reverse(Request& r, MethodParams& params) {
	VHashBase& self=GET_SELF(r, VHashBase);
	HashStringValue& source_hash=self.hash();
	HashStringValue& result_hash=*new HashStringValue();

	#ifdef HASH_ORDER
	for(HashStringValue::ReverseIterator i(source_hash); i; i.prev())
	result_hash.put(i.key(), i.value());
	#else
	for(HashStringValue::Iterator i(source_hash); i; i.next() )
	result_hash.put(i.key(), i.value());
	#endif

	VHashBase& result=*new VHash(result_hash);
	if(Value* vdefault=self.get_default())
	result.set_default(vdefault);

	r.write(result);
	}


	static void _rename(Request& r, MethodParams& params) {
	HashStringValue& hash=GET_SELF(r, VHashBase).hash();

	if(params.count()>1){
	const String& key_from=params.as_string(0, "from key must be string");
	const String& key_to=params.as_string(1, "to key must be string");

	hash.rename(key_from, key_to);
	} else {
	HashStringValue* names=params.as_hash(0,"single parameter");

	for(HashStringValue::Iterator i(*names); i; i.next())
	hash.rename(i.key(), i.value()->as_string());
	}
	}


// constructor	// constructor

MHash::MHash(): Methoded("hash")	MHash::MHash(): Methoded("hash")
Line 671 MHash::MHash(): Methoded("hash")	Line 797 MHash::MHash(): Methoded("hash")
add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);	add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);
// ^a.union[b] = hash	// ^a.union[b] = hash
add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);	add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);
// ^a.intersection[b] = hash	// ^a.intersection[b][options hash] = hash
add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 1);	add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 2);
// ^a.intersects[b] = bool	// ^a.intersects[b] = bool
add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);	add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);

Line 698 MHash::MHash(): Methoded("hash")	Line 824 MHash::MHash(): Methoded("hash")

// ^hash.sort[key;value]{string-key-maker}[[asc\|desc]]	// ^hash.sort[key;value]{string-key-maker}[[asc\|desc]]
// ^hash.sort[key;value](numeric-key-maker)[[asc\|desc]]	// ^hash.sort[key;value](numeric-key-maker)[[asc\|desc]]
add_native_method("sort", Method::CT_DYNAMIC, _sort, 2+1, 2+1+1);	add_native_method("sort", Method::CT_DYNAMIC, _sort, 3, 4);

	// ^hash.select[key;value](bool-condition)[options hash]
	add_native_method("select", Method::CT_DYNAMIC, _select, 3, 4);

	// ^hash.reverse[]
	add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0);

// ^hash._at[first\|last[;'key'\|'value'\|'hash']]	// ^hash._at[first\|last[;'key'\|'value'\|'hash']]
// ^hash._at([-+]offset)[['key'\|'value'\|'hash']]	// ^hash._at([-+]offset)[['key'\|'value'\|'hash']]
add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);	add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);

	// ^hash.rename[from;to]
	// ^hash.rename[ $.from[to] ... ]
	add_native_method("rename", Method::CT_DYNAMIC, _rename, 1, 2);

#ifdef FEATURE_GET_ELEMENT4CALL	#ifdef FEATURE_GET_ELEMENT4CALL
// aliases without "_"	// aliases without "_"
add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);	add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);

E-mail:

Removed from v.1.129
changed lines
	Added in v.1.164