parser3/src/classes/table.C - diff

Return to table.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/table.C between versions 1.368 and 1.382

version 1.368, 2024/10/20 13:29:37	version 1.382, 2026/01/08 21:13:03
Line 1	Line 1
/** @file	/** @file
Parser: @b table parser class.	Parser: @b table parser class.

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

Line 404 static void skip_empty_lines( char** dat	Line 404 static void skip_empty_lines( char** dat
typedef void (Skip_lines_action)(char* data_ref);	typedef void (Skip_lines_action)(char* data_ref);

static void _load(Request& r, MethodParams& params) {	static void _load(Request& r, MethodParams& params) {
const String& first_param=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& first_param=params.as_file_name(0);
int filename_param_index=0;	int filename_param_index=0;
bool nameless=first_param=="nameless";	bool nameless=first_param=="nameless";
if(nameless)	if(nameless)
Line 417 static void _load(Request& r, MethodPara	Line 417 static void _load(Request& r, MethodPara
control_chars.load(*options);	control_chars.load(*options);

// loading text	// loading text
char *data=file_load_text(r, r.full_disk_path(params.as_string(filename_param_index, FILE_NAME_MUST_BE_STRING)), true, options);	char *data=file_load_text(r, r.full_disk_path(params.as_file_name(filename_param_index)), true, options);

Skip_lines_action skip_lines_action = (control_chars.separator=='#' \|\| control_chars.encloser=='#') ? skip_empty_lines : skip_empty_and_comment_lines;	Skip_lines_action skip_lines_action = (control_chars.separator=='#' \|\| control_chars.encloser=='#') ? skip_empty_lines : skip_empty_and_comment_lines;

Line 624 static void table_to_csv(String& result,	Line 624 static void table_to_csv(String& result,


static void _save(Request& r, MethodParams& params) {	static void _save(Request& r, MethodParams& params) {
const String& first_arg=params.as_string(0, FIRST_ARG_MUST_NOT_BE_CODE);	const String& first_arg=params.as_string(0, PARAMETER_MUST_BE_STRING);
size_t param_index=1;	size_t param_index=1;

bool do_append=false;	bool do_append=false;
Line 638 static void _save(Request& r, MethodPara	Line 638 static void _save(Request& r, MethodPara
else	else
--param_index;	--param_index;

const String& file_name=params.as_string(param_index++, FILE_NAME_MUST_NOT_BE_CODE);	const String& file_name=params.as_file_name(param_index++);
String file_spec=r.full_disk_path(file_name);	String file_spec=r.full_disk_path(file_name);

if(do_append && file_exist(file_spec))	if(do_append && file_exist(file_spec))
Line 683 static void _csv_string(Request& r, Meth	Line 683 static void _csv_string(Request& r, Meth
bool output_column_names=true;	bool output_column_names=true;
size_t param_index=0;	size_t param_index=0;
if(params.count()>0 && params[0].is_string()) {	if(params.count()>0 && params[0].is_string()) {
if(params.as_string(0, FIRST_ARG_MUST_NOT_BE_CODE)=="nameless") {	if(params.as_string(0, PARAM_MUST_NOT_BE_CODE)=="nameless") {
output_column_names=false;	output_column_names=false;
param_index++;	param_index++;
} else {	} else {
Line 751 static void _offset(Request& r, MethodPa	Line 751 static void _offset(Request& r, MethodPa
else if(whence=="set")	else if(whence=="set")
absolute=true;	absolute=true;
else	else
throw Exception(PARSER_RUNTIME, &whence, "is invalid whence, valid are 'cur' or 'set'");	throw Exception(PARSER_RUNTIME, &whence, "is an invalid whence, valid are 'cur' or 'set'");
}	}

int offset=params.as_int(params.count()-1, "offset must be expression", r);	int offset=params.as_int(params.count()-1, "offset must be expression", r);
Line 768 static void _menu(Request& r, MethodPara	Line 768 static void _menu(Request& r, MethodPara
Value* delim_maybe_code=params.count()>1?&params[1]:0;	Value* delim_maybe_code=params.count()>1?&params[1]:0;

Table& table=GET_SELF(r, VTable).table();	Table& table=GET_SELF(r, VTable).table();
size_t saved_current=table.current();	Temp_current tc(table);

if(delim_maybe_code) { // delimiter set	if(delim_maybe_code) { // delimiter set
bool need_delim=false;	bool need_delim=false;
Line 801 static void _menu(Request& r, MethodPara	Line 801 static void _menu(Request& r, MethodPara
break;	break;
}	}
}	}
table.set_current(saved_current);
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
Line 850 static void table_row_to_hash(Table::ele	Line 849 static void table_row_to_hash(Table::ele
for(Array_iterator<int> i(*info->value_fields); i; ) {	for(Array_iterator<int> i(*info->value_fields); i; ) {
size_t value_field=i.next();	size_t value_field=i.next();
if(value_field<row->count())	if(value_field<row->count())
hash.put(columns ? columns->get(value_field) : String(pa_uitoa(value_field)), new VString(row->get(value_field)));	hash.put(columns ? columns->get(value_field) : String::Body::uitoa(value_field), new VString(row->get(value_field)));
}	}
} else { // all fields	} else { // all fields
for(size_t index=0; index<row->count(); index++) {	for(size_t index=0; index<row->count(); index++) {
hash.put(columns && index < columns->count() ? columns->get(index) : String(pa_uitoa(index)), new VString(row->get(index)));	hash.put(columns && index < columns->count() ? columns->get(index) : String::Body::uitoa(index), new VString(row->get(index)));
}	}
}	}
exist=info->hash->put_dont_replace(*key, vhash);	exist=info->hash->put_dont_replace(*key, vhash);
Line 1002 static void _hash(Request& r, MethodPara	Line 1001 static void _hash(Request& r, MethodPara
};	};
info.key_field=(info.key_code ? -1 : self_table.column_name2index(key_param->as_string(), true));	info.key_field=(info.key_code ? -1 : self_table.column_name2index(key_param->as_string(), true));

int saved_current=self_table.current();	Temp_current tc(self_table);
self_table.for_each(table_row_to_hash, &info);	for(Table::RobustIterator i(self_table); i; i.next()) {
self_table.set_current(saved_current);	table_row_to_hash(i.value(), &info);
	}

result.extract_default();	result.extract_default();

r.write(result);	r.write(result);
}	}

	static void _array(Request& r, MethodParams& params) {
	Table& table=GET_SELF(r, VTable).table();
	VArray& result=*new VArray;
	ArrayValue& array=result.array();

	Table2hash_value_type value_type=C_HASH;
	Array<int> value_fields;
	Value* value_code=0;

	if(params.count()>0) {
	if(params[0].get_junction()){
	value_type=C_CODE;
	value_code=&params[0];
	} else if(params[0].is_string()) {
	const String &field_name=*params[0].get_string();
	if(!field_name.is_empty()){
	value_type=C_STRING;
	value_fields+=table.column_name2index(field_name, true);
	}
	} else {
	throw Exception(PARSER_RUNTIME, 0, "value field must be string or code or empty");
	}
	}

	Temp_current tc(table);
	for(Table::RobustIterator i(table); i; i.next()) {
	switch(value_type) {
	case C_STRING: {
	size_t index=value_fields.get(0);
	Table::element_type row=i.value();
	array+=(index < row->count() ? new VString(*row->get(index)) : VString::empty());
	break;
	}
	case C_HASH: {
	VHash* vhash=new VHash;
	HashStringValue& hash=vhash->hash();
	Table::element_type row=i.value();
	Table::columns_type columns=table.columns();
	for(size_t index=0; index<row->count(); index++) {
	hash.put(columns && index < columns->count() ? columns->get(index) : String(pa_uitoa(index)), new VString(row->get(index)));
	}
	array+=vhash;
	break;
	}
	case C_CODE: {
	table.set_current(i.index());
	array+=&r.process(*value_code);
	break;
	}
	}
	}

	r.write(result);
	}

static void _cells(Request& r, MethodParams& params) {	static void _cells(Request& r, MethodParams& params) {
Table& self_table=GET_SELF(r, VTable).table();	Table& self_table=GET_SELF(r, VTable).table();
size_t row_size=self_table[self_table.current()]->count(); // number of columns in current row	size_t row_size=self_table[self_table.current()]->count(); // number of columns in current row

if(params.count()){	if(params.count()){
int limit=params.as_int(params.count()-1, "offset must be expression", r);	int limit=params.as_int(params.count()-1, "limit must be expression", r);
if(limit<0)	if(limit<0)
limit=0;	limit=0;
if((size_t)limit<row_size)	if((size_t)limit<row_size)
Line 1030 static void _cells(Request& r, MethodPar	Line 1085 static void _cells(Request& r, MethodPar
const String* column_item=self_table.item(index);	const String* column_item=self_table.item(index);
result_array+=column_item ? new VString(*column_item) : VString::empty();	result_array+=column_item ? new VString(*column_item) : VString::empty();
}	}

	result_array.confirm_all_used();
r.write(result);	r.write(result);
}	}

Line 1171 static void _foreach(Request& r, MethodP	Line 1228 static void _foreach(Request& r, MethodP
Value* delim_maybe_code=params.count()>3?&params[3]:0;	Value* delim_maybe_code=params.count()>3?&params[3]:0;

Table& table=GET_SELF(r, VTable).table();	Table& table=GET_SELF(r, VTable).table();
size_t saved_current=table.current();	Temp_current tc(table);

rownum_var_name=rownum_var_name->is_empty()? 0 : rownum_var_name;	rownum_var_name=rownum_var_name->is_empty()? 0 : rownum_var_name;
value_var_name=value_var_name->is_empty()? 0 : value_var_name;	value_var_name=value_var_name->is_empty()? 0 : value_var_name;
Line 1219 static void _foreach(Request& r, MethodP	Line 1276 static void _foreach(Request& r, MethodP
break;	break;
}	}
}	}
table.set_current(saved_current);
}	}

static void update_cell(HashStringValue::key_type aname, HashStringValue::value_type avalue, VTable *dest) {	static void update_cell(HashStringValue::key_type aname, HashStringValue::value_type avalue, VTable *dest) {
Line 1245 static void _append(Request& r, MethodPa	Line 1301 static void _append(Request& r, MethodPa

HashStringValue* hash=params[0].get_hash();	HashStringValue* hash=params[0].get_hash();
if(hash){	if(hash){
	Temp_current tc(table);
table+=new ArrayString();	table+=new ArrayString();
size_t saved_current=table.current();
table.set_current(table.count()-1);	table.set_current(table.count()-1);
hash->for_each<VTable*>(update_cell, &vtable);	hash->for_each<VTable*>(update_cell, &vtable);
table.set_current(saved_current);
} else {	} else {
table+=row_from_string(r, params[0]);	table+=row_from_string(r, params[0]);
}	}

	if(table.count() > pa_array_limit)
	throw Exception(PARSER_RUNTIME, 0, "table size (%d) exceeds limit $MAIN:LIMITS.max_array_size (%d)", table.count(), pa_array_limit);
}	}

static void _insert(Request& r, MethodParams& params) {	static void _insert(Request& r, MethodParams& params) {
Line 1265 static void _insert(Request& r, MethodPa	Line 1323 static void _insert(Request& r, MethodPa
} else {	} else {
table.insert(table.current(), row_from_string(r, params[0]));	table.insert(table.current(), row_from_string(r, params[0]));
}	}

	if(table.count() > pa_array_limit)
	throw Exception(PARSER_RUNTIME, 0, "table size (%d) exceeds limit $MAIN:LIMITS.max_array_size (%d)", table.count(), pa_array_limit);
}	}

static void _delete(Request& r, MethodParams&) {	static void _delete(Request& r, MethodParams&) {
Line 1384 void unmarshal_bind_updates(HashStringVa	Line 1445 void unmarshal_bind_updates(HashStringVa
if(ph->is_null)	if(ph->is_null)
value=VVoid::get();	value=VVoid::get();
else	else
value=new VString(*new String(ph->value, String::L_TAINTED));	value=new VString(ph->value);
hash.put(ph->name, value);	hash.put(ph->name, value);
}	}
}	}
Line 1500 static void _select(Request& r, MethodPa	Line 1561 static void _select(Request& r, MethodPa
if(offset<0)	if(offset<0)
offset+=size;	offset+=size;
if(size && limit>0 && offset>=0 && (size_t)offset<size){	if(size && limit>0 && offset>=0 && (size_t)offset<size){
size_t saved_current=source_table.current();	Temp_current tcurrent(source_table);
size_t appended=0;	size_t appended=0;

if(reverse){	if(reverse){
Line 1512 static void _select(Request& r, MethodPa	Line 1573 static void _select(Request& r, MethodPa
if(r.check_skip_break())	if(r.check_skip_break())
break;	break;

if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result	if(condition && ++appended > (size_t)offset && source_table.valid(row)) // ...condition is true, adding to the result
result_table+=source_table[row];	result_table+=source_table[row];
if(row==0) break;	if(row==0) break;
}	}
Line 1525 static void _select(Request& r, MethodPa	Line 1586 static void _select(Request& r, MethodPa
if(r.check_skip_break())	if(r.check_skip_break())
break;	break;

if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result	if(condition && ++appended > (size_t)offset && source_table.valid(row)) // ...condition is true, adding to the result
result_table+=source_table[row];	result_table+=source_table[row];
}	}
}	}
source_table.set_current(saved_current);
}	}

r.write(*new VTable(&result_table));	r.write(*new VTable(&result_table));
Line 1618 MTable::MTable(): Methoded("table") {	Line 1678 MTable::MTable(): Methoded("table") {
// ^table.hash[key field name][value field name(s) string/table]	// ^table.hash[key field name][value field name(s) string/table]
add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3);	add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3);

	// ^table.array[]
	// ^table.array[string]
	// ^table.array{code}
	add_native_method("array", Method::CT_DYNAMIC, _array, 0, 1);

// ^table.cells[]	// ^table.cells[]
// ^table.cells(limit)	// ^table.cells(limit)
add_native_method("cells", Method::CT_DYNAMIC, _cells, 0, 1);	add_native_method("cells", Method::CT_DYNAMIC, _cells, 0, 1);

E-mail:

Removed from v.1.368
changed lines
	Added in v.1.382