Annotation of parser3/src/classes/hash.C, revision 1.137
1.1 paf 1: /** @file
2: Parser: @b hash parser class.
3:
1.125 moko 4: Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)
1.35 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.41 paf 6: */
1.1 paf 7:
8: #include "classes.h"
1.57 paf 9: #include "pa_vmethod_frame.h"
10:
1.1 paf 11: #include "pa_request.h"
1.122 moko 12: #include "pa_charsets.h"
1.1 paf 13: #include "pa_vhash.h"
1.6 parser 14: #include "pa_vvoid.h"
1.2 parser 15: #include "pa_sql_connection.h"
1.9 parser 16: #include "pa_vtable.h"
1.22 parser 17: #include "pa_vbool.h"
1.26 paf 18: #include "pa_vmethod_frame.h"
1.2 parser 19:
1.137 ! moko 20: volatile const char * IDENT_HASH_C="$Id: hash.C,v 1.136 2016/10/26 15:44:49 moko Exp $";
1.113 moko 21:
1.1 paf 22: // class
23:
1.57 paf 24: class MHash: public Methoded {
1.2 parser 25: public: // VStateless_class
1.103 misha 26: Value* create_new_value(Pool&) { return new VHash(); }
1.2 parser 27:
1.1 paf 28: public:
1.57 paf 29: MHash();
1.1 paf 30: };
31:
1.57 paf 32: // global variable
33:
1.126 moko 34: DECLARE_CLASS_VAR(hash, new MHash);
1.57 paf 35:
1.1 paf 36: // methods
37:
1.11 parser 38: #ifndef DOXYGEN
1.52 paf 39: class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {
1.57 paf 40: const String& statement_string; const char* statement_cstr;
41: bool distinct;
42: HashStringValue& rows_hash;
1.86 misha 43: Value* row_value;
1.57 paf 44: int column_index;
1.86 misha 45: ArrayString& columns;
46: bool one_bool_column;
1.67 paf 47: static VBool only_one_column_value;
1.86 misha 48: Table2hash_value_type value_type;
49: int columns_count;
50: public:
51: Table* empty;
1.11 parser 52: public:
1.57 paf 53: Hash_sql_event_handlers(
1.86 misha 54: const String& astatement_string,
55: const char* astatement_cstr,
1.49 paf 56: bool adistinct,
1.86 misha 57: HashStringValue& arows_hash,
58: Table2hash_value_type avalue_type)
59: :
60: statement_string(astatement_string),
61: statement_cstr(astatement_cstr),
1.49 paf 62: distinct(adistinct),
1.11 parser 63: rows_hash(arows_hash),
1.86 misha 64: value_type(avalue_type),
65: row_value(0),
1.67 paf 66: column_index(0),
1.86 misha 67: one_bool_column(false),
68: columns(*new ArrayString),
69: empty(0) {
1.11 parser 70: }
1.86 misha 71:
1.109 misha 72: bool add_column(SQL_Error& error, const char* str, size_t ) {
1.53 paf 73: try {
1.107 moko 74: columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */);
1.53 paf 75: return false;
76: } catch(...) {
77: error=SQL_Error("exception occured in Hash_sql_event_handlers::add_column");
78: return true;
79: }
1.11 parser 80: }
1.86 misha 81:
1.53 paf 82: bool before_rows(SQL_Error& error) {
1.67 paf 83: if(columns.count()<1) {
1.79 misha 84: error=SQL_Error(PARSER_RUNTIME, "no columns");
1.53 paf 85: return true;
86: }
1.86 misha 87: switch(value_type){
88: case C_STRING: {
89: if(columns.count()>2){
90: error=SQL_Error(PARSER_RUNTIME, "only 2 columns allowed for $.type[string].");
91: return true;
92: }
93: }
94: case C_TABLE: {
95: // create empty table which we'll copy later
96: empty=new Table(&columns);
97: columns_count=columns.count();
98: }
99: case C_HASH: {
100: one_bool_column=columns.count()==1;
101: }
102: }
1.53 paf 103: return false;
1.11 parser 104: }
1.86 misha 105:
1.53 paf 106: bool add_row(SQL_Error& /*error*/) {
1.11 parser 107: column_index=0;
1.53 paf 108: return false;
1.11 parser 109: }
1.86 misha 110:
1.116 misha 111: bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
1.53 paf 112: try {
1.116 misha 113: const String& cell=str?*new String(str, String::L_TAINTED /* no length as 0x00 can be inside */):String::Empty;
1.86 misha 114:
1.69 paf 115: bool duplicate=false;
1.86 misha 116: if(one_bool_column) {
1.69 paf 117: duplicate=rows_hash.put_dont_replace(cell, &only_one_column_value); // put. existed?
118: } else if(column_index==0) {
1.86 misha 119: switch(value_type){
120: case C_HASH: {
121: VHash* row_vhash=new VHash;
122: row_value=row_vhash;
123: duplicate=rows_hash.put_dont_replace(cell, row_vhash); // put. existed?
124: break;
125: }
126: case C_STRING: {
127: VString* row_vstring=new VString();
128: row_value=row_vstring;
129: duplicate=rows_hash.put_dont_replace(cell, row_vstring); // put. existed?
130: break;
131: }
132: case C_TABLE: {
133: VTable* vtable=(VTable*)rows_hash.get(cell);
134: Table* table;
135:
136: if(vtable) { // table with this key exist?
137: if(!distinct) {
138: duplicate=true;
139: break;
140: }
141: table=vtable->get_table();
142: } else {
143: // no? creating table of same structure as source
144: Table::Action_options table_options(0, 0);
145: table=new Table(*empty, table_options/*no rows, just structure*/);
146: vtable=new VTable(table);
147: rows_hash.put(cell, vtable); // put
148: }
149: ArrayString* row=new ArrayString(columns_count);
150: row_value=(Value*)row;
151: *row+=&cell;
152: *table+=row;
153: break;
154: }
155: }
156: } else {
157: switch(value_type) {
158: case C_HASH: {
159: row_value->get_hash()->put(*columns[column_index], new VString(cell));
160: break;
161: }
162: case C_STRING: {
163: VString* row_string=(VString*)row_value;
164: row_string->set_string(cell);
165: break;
166: }
167: case C_TABLE: {
168: ArrayString* row=(ArrayString*)row_value;
169: *row+=&cell;
170: break;
171: }
172: }
173: }
1.69 paf 174:
175: if(duplicate & !distinct) {
1.79 misha 176: error=SQL_Error(PARSER_RUNTIME, "duplicate key");
1.69 paf 177: return true;
178: }
179:
1.53 paf 180: column_index++;
181: return false;
182: } catch(...) {
183: error=SQL_Error("exception occured in Hash_sql_event_handlers::add_row_cell");
184: return true;
185: }
1.11 parser 186: }
187:
188: };
1.67 paf 189: VBool Hash_sql_event_handlers::only_one_column_value(true);
190:
1.11 parser 191: #endif
192:
1.57 paf 193: static void _create_or_add(Request& r, MethodParams& params) {
194: if(params.count()) {
1.111 misha 195: Value& vsrc=params.as_no_junction(0, PARAM_MUST_BE_HASH);
1.130 moko 196: VHashBase& self=GET_SELF(r, VHashBase);
197: HashStringValue* self_hash=&(self.hash());
1.115 moko 198: HashStringValue* src_hash;
199:
1.130 moko 200: if(VHashBase* src=static_cast<VHashBase*>(vsrc.as(VHASH_TYPE))) {
1.127 moko 201: src_hash=&(src->hash());
1.115 moko 202:
203: if(src_hash==self_hash) // same: doing nothing
1.66 paf 204: return;
1.72 paf 205:
1.115 moko 206: if(Value* vdefault=src->get_default())
1.129 moko 207: self.set_default(vdefault);
1.115 moko 208: } else {
209: src_hash=vsrc.get_hash();
1.66 paf 210: }
1.115 moko 211:
212: if(src_hash)
213: src_hash->for_each<HashStringValue*>(copy_all_overwrite_to, self_hash);
1.20 parser 214: }
215: }
1.22 parser 216:
1.57 paf 217: static void _sub(Request& r, MethodParams& params) {
1.114 misha 218: if(HashStringValue* src=params.as_hash(0, "param")) {
1.130 moko 219: HashStringValue* self=&(GET_SELF(r, VHashBase).hash());
1.66 paf 220: if(src==self) { // same: clearing
221: self->clear();
222: return;
223: }
1.77 paf 224: src->for_each<HashStringValue*>(remove_key_from, self);
1.66 paf 225: }
1.57 paf 226: }
227:
1.130 moko 228: static void copy_all_dontoverwrite_to(HashStringValue::key_type key, HashStringValue::value_type value, HashStringValue* dest) {
1.57 paf 229: dest->put_dont_replace(key, value);
1.22 parser 230: }
1.57 paf 231: static void _union(Request& r, MethodParams& params) {
1.22 parser 232: // dest = copy of self
1.130 moko 233: Value& result=*new VHash(GET_SELF(r, VHashBase).hash());
1.22 parser 234: // dest += b
1.114 misha 235: if(HashStringValue* src=params.as_hash(0, "param"))
1.77 paf 236: src->for_each<HashStringValue*>(copy_all_dontoverwrite_to, result.get_hash());
1.22 parser 237:
238: // return result
1.137 ! moko 239: r.write(result);
1.22 parser 240: }
241:
242: #ifndef DOXYGEN
243: struct Copy_intersection_to_info {
1.57 paf 244: HashStringValue* b;
245: HashStringValue* dest;
1.22 parser 246: };
247: #endif
1.130 moko 248: static void copy_intersection_to(HashStringValue::key_type key, HashStringValue::value_type value, Copy_intersection_to_info *info) {
1.57 paf 249: if(info->b->get(key))
250: info->dest->put_dont_replace(key, value);
1.22 parser 251: }
1.57 paf 252: static void _intersection(Request& r, MethodParams& params) {
253: Value& result=*new VHash;
1.22 parser 254: // dest += b
1.114 misha 255: if(HashStringValue* b=params.as_hash(0, "param")) {
1.57 paf 256: Copy_intersection_to_info info={b, result.get_hash()};
1.130 moko 257: GET_SELF(r, VHashBase).hash().for_each<Copy_intersection_to_info*>(copy_intersection_to, &info);
1.22 parser 258: }
259:
260: // return result
1.137 ! moko 261: r.write(result);
1.22 parser 262: }
263:
1.130 moko 264: static bool intersects( HashStringValue::key_type key, HashStringValue::value_type /*value*/, HashStringValue* b) {
1.57 paf 265: return b->get(key)!=0;
1.22 parser 266: }
267:
1.57 paf 268: static void _intersects(Request& r, MethodParams& params) {
269: bool result=false;
270:
1.119 misha 271: if(HashStringValue* b=params.as_hash(0, "param")) {
1.130 moko 272: HashStringValue* self=&(GET_SELF(r, VHashBase).hash());
1.120 misha 273: if(b==self) {
1.137 ! moko 274: r.write(VBool::get(true));
1.120 misha 275: return;
276: }
1.119 misha 277: result=self->first_that<HashStringValue*>(intersects, b)!=0;
278: }
1.22 parser 279:
280: // return result
1.137 ! moko 281: r.write(VBool::get(result));
1.22 parser 282: }
283:
284:
1.71 paf 285: extern String sql_bind_name;
1.57 paf 286: extern String sql_limit_name;
287: extern String sql_offset_name;
288: extern String sql_default_name;
289: extern String sql_distinct_name;
1.81 misha 290: extern String sql_value_type_name;
291: extern Table2hash_value_type get_value_type(Value& vvalue_type);
1.71 paf 292: extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
293: extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
294:
1.57 paf 295: static void _sql(Request& r, MethodParams& params) {
296: Value& statement=params.as_junction(0, "statement must be code");
1.2 parser 297:
1.71 paf 298: HashStringValue* bind=0;
1.87 misha 299: ulong limit=SQL_NO_LIMIT;
1.33 paf 300: ulong offset=0;
1.49 paf 301: bool distinct=false;
1.81 misha 302: Table2hash_value_type value_type=C_HASH;
1.110 misha 303: if(params.count()>1)
1.114 misha 304: if(HashStringValue* options=params.as_hash(1, "sql options")) {
1.110 misha 305: int valid_options=0;
306: if(Value* vbind=options->get(sql_bind_name)) {
307: valid_options++;
308: bind=vbind->get_hash();
309: }
310: if(Value* vlimit=options->get(sql_limit_name)) {
311: valid_options++;
1.133 moko 312: limit=(ulong)r.process(*vlimit).as_double();
1.110 misha 313: }
314: if(Value* voffset=options->get(sql_offset_name)) {
315: valid_options++;
1.133 moko 316: offset=(ulong)r.process(*voffset).as_double();
1.110 misha 317: }
318: if(Value* vdistinct=options->get(sql_distinct_name)) {
319: valid_options++;
1.133 moko 320: distinct=r.process(*vdistinct).as_bool();
1.110 misha 321: }
322: if(Value* vvalue_type=options->get(sql_value_type_name)) {
323: valid_options++;
1.133 moko 324: value_type=get_value_type(r.process(*vvalue_type));
1.110 misha 325: }
326: if(valid_options!=options->count())
327: throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
328: }
1.2 parser 329:
1.71 paf 330: SQL_Driver::Placeholder* placeholders=0;
331: uint placeholders_count=0;
332: if(bind)
333: placeholders_count=marshal_binds(*bind, placeholders);
334:
1.37 paf 335: const String& statement_string=r.process_to_string(statement);
1.136 moko 336: const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());
1.97 misha 337:
1.130 moko 338: HashStringValue& hash=GET_SELF(r, VHashBase).hash();
1.11 parser 339: hash.clear();
1.57 paf 340: Hash_sql_event_handlers handlers(
1.49 paf 341: statement_string, statement_cstr,
342: distinct,
1.86 misha 343: hash,
344: value_type);
1.87 misha 345:
1.57 paf 346: r.connection()->query(
1.70 paf 347: statement_cstr,
1.73 paf 348: placeholders_count, placeholders,
1.70 paf 349: offset, limit,
1.45 paf 350: handlers,
351: statement_string);
1.71 paf 352:
353: if(bind)
354: unmarshal_bind_updates(*bind, placeholders_count, placeholders);
1.2 parser 355: }
356:
1.130 moko 357: static void keys_collector(HashStringValue::key_type key, HashStringValue::value_type, Table *table) {
1.100 misha 358: Table::element_type row(new ArrayString(1));
1.57 paf 359: *row+=new String(key, String::L_TAINTED);
360: *table+=row;
1.9 parser 361: }
1.68 paf 362: static void _keys(Request& r, MethodParams& params) {
363: const String* keys_column_name;
364: if(params.count()>0)
1.81 misha 365: keys_column_name=¶ms.as_string(0, COLUMN_NAME_MUST_BE_STRING);
1.68 paf 366: else
367: keys_column_name=new String("key");
368:
1.101 misha 369: Table::columns_type columns(new ArrayString(1));
1.68 paf 370: *columns+=keys_column_name;
1.57 paf 371: Table* table=new Table(columns);
1.9 parser 372:
1.130 moko 373: GET_SELF(r, VHashBase).hash().for_each<Table*>(keys_collector, table);
1.9 parser 374:
1.137 ! moko 375: r.write(*new VTable(table));
1.9 parser 376: }
377:
1.57 paf 378: static void _count(Request& r, MethodParams&) {
1.137 ! moko 379: r.write(*new VInt(GET_SELF(r, VHashBase).hash().count()));
1.16 parser 380: }
381:
1.57 paf 382: static void _delete(Request& r, MethodParams& params) {
1.119 misha 383: if(params.count()>0)
1.130 moko 384: GET_SELF(r, VHashBase).hash().remove(params.as_string(0, "key must be string"));
1.119 misha 385: else
1.130 moko 386: GET_SELF(r, VHashBase).hash().clear();
1.25 paf 387: }
388:
1.82 misha 389: static void _contains(Request& r, MethodParams& params) {
1.130 moko 390: VHashBase& self=GET_SELF(r, VHashBase);
1.129 moko 391: const String& key_name=params.as_string(0, "key must be string");
392: bool result=SYMBOLS_EQ(key_name,_DEFAULT_SYMBOL) ? (self.get_default() != 0) : self.hash().contains(key_name);
1.137 ! moko 393: r.write(VBool::get(result));
1.80 misha 394: }
395:
1.57 paf 396: static void _foreach(Request& r, MethodParams& params) {
1.102 misha 397: InCycle temp(r);
1.77 paf 398:
1.128 moko 399: const String* key_var_name=¶ms.as_string(0, "key-var name must be string");
400: const String* value_var_name=¶ms.as_string(1, "value-var name must be string");
401: Value* body_code=¶ms.as_junction(2, "body must be code");
1.134 moko 402: Value* delim_maybe_code=params.count()>3?¶ms[3]:0;
1.128 moko 403: Value& caller=*r.get_method_frame()->caller();
1.85 misha 404:
1.128 moko 405: if(key_var_name->is_empty()) key_var_name=0;
406: if(value_var_name->is_empty()) value_var_name=0;
1.57 paf 407:
1.130 moko 408: HashStringValue& hash=GET_SELF(r, VHashBase).hash();
1.128 moko 409:
410: if(delim_maybe_code){ // delimiter set
411: bool need_delim=false;;
412: for(HashStringValue::Iterator i(hash); i; i.next()){
413: if(key_var_name){
414: VString* vkey=new VString(*new String(i.key(), String::L_TAINTED));
415: r.put_element(caller, *key_var_name, vkey);
416: }
417:
418: if(value_var_name)
419: r.put_element(caller, *value_var_name, i.value());
420:
1.132 moko 421: Value& sv_processed=r.process(*body_code);
1.128 moko 422: Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);
423:
424: const String* s_processed=sv_processed.get_string();
425: if(s_processed && !s_processed->is_empty()) { // we have body
426: if(need_delim) // need delim & iteration produced string?
1.137 ! moko 427: r.write(r.process(*delim_maybe_code));
1.128 moko 428: else
429: need_delim=true;
430: }
431:
1.137 ! moko 432: r.write(sv_processed);
1.128 moko 433:
434: if(lskip==Request::SKIP_BREAK)
435: break;
436: }
437: } else {
438: for(HashStringValue::Iterator i(hash); i; i.next()){
439: if(key_var_name){
440: VString* vkey=new VString(*new String(i.key(), String::L_TAINTED));
441: r.put_element(caller, *key_var_name, vkey);
442: }
443:
444: if(value_var_name)
445: r.put_element(caller, *value_var_name, i.value());
446:
447: r.process_write(*body_code);
448: Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);
449:
450: if(lskip==Request::SKIP_BREAK)
451: break;
452: }
453: }
1.26 paf 454: }
455:
1.121 misha 456: enum AtResultType {
457: AtResultTypeValue = 0,
458: AtResultTypeKey = 1,
459: AtResultTypeHash = 2
460: };
461:
462: inline Value& SingleElementHash(String::Body akey, Value* avalue) {
463: Value& result=*new VHash;
464: result.put_element(*new String(akey, String::L_TAINTED), avalue);
465: return result;
466: }
467:
1.122 moko 468: #ifndef DOXYGEN
469: struct Hash_seq_item {
470: HashStringValue::Pair *hash_pair;
471: union {
472: const char *c_str;
473: double d;
474: } value;
475: };
476: #endif
477: static int sort_cmp_string(const void *a, const void *b) {
478: return strcmp(
479: static_cast<const Hash_seq_item *>(a)->value.c_str,
480: static_cast<const Hash_seq_item *>(b)->value.c_str
481: );
482: }
483: static int sort_cmp_double(const void *a, const void *b) {
484: double va=static_cast<const Hash_seq_item *>(a)->value.d;
485: double vb=static_cast<const Hash_seq_item *>(b)->value.d;
486: if(va<vb)
487: return -1;
488: else if(va>vb)
489: return +1;
490: else
491: return 0;
492: }
493: static void _sort(Request& r, MethodParams& params){
1.123 moko 494: #ifdef HASH_ORDER
1.122 moko 495: const String& key_var_name=params.as_string(0, "key-var name must be string");
496: const String& value_var_name=params.as_string(1, "value-var name must be string");
497: Value& key_maker=params.as_junction(2, "key-maker must be code");
498: bool reverse=params.count()>3/*..[desc|asc|]*/?
499: reverse=params.as_no_junction(3, "order must not be code").as_string()=="desc":
500: false; // default=asc
501:
502: const String* key_var=key_var_name.is_empty()? 0 : &key_var_name;
503: const String* value_var=value_var_name.is_empty()? 0 : &value_var_name;
504: VMethodFrame* context=r.get_method_frame()->caller();
505:
1.130 moko 506: HashStringValue& hash=GET_SELF(r, VHashBase).hash();
1.122 moko 507: int count=hash.count();
508:
509: Hash_seq_item* seq=new(PointerFreeGC) Hash_seq_item[count];
510: int pos=0;
511: bool key_values_are_strings=true;
512:
513: for(HashStringValue::Iterator i(hash); i; i.next(), pos++ ){
514: if(key_var)
515: r.put_element(*context, *key_var, new VString(*new String(i.key(), String::L_TAINTED)));
516: if(value_var)
517: r.put_element(*context, *value_var, i.value());
518:
1.133 moko 519: Value& value=r.process(key_maker);
1.122 moko 520: if(pos==0) // determining key values type by first one
521: key_values_are_strings=value.is_string();
522:
523: seq[pos].hash_pair=i.pair();
524: if(key_values_are_strings)
525: seq[pos].value.c_str=value.as_string().cstr();
526: else
527: seq[pos].value.d=value.as_expr_result().as_double();
528: }
529:
530: // @todo: handle this elsewhere
531: if(r.charsets.source().NAME()=="KOI8-R" && key_values_are_strings)
532: for(pos=0; pos<count; pos++)
533: if(*seq[pos].value.c_str)
1.131 moko 534: seq[pos].value.c_str=Charset::transcode(seq[pos].value.c_str, r.charsets.source(), pa_UTF8_charset).cstr();
1.122 moko 535:
536: // sort keys
537: qsort(seq, count, sizeof(Hash_seq_item), key_values_are_strings?sort_cmp_string:sort_cmp_double);
538:
539: // reorder hash as required in 'seq'
540: hash.order_clear();
541: if(reverse)
542: for(pos=count-1; pos>=0; pos--)
543: hash.order_next(seq[pos].hash_pair);
544: else
545: for(pos=0; pos<count; pos++)
546: hash.order_next(seq[pos].hash_pair);
547:
548: delete[] seq;
1.123 moko 549: #endif
1.122 moko 550: }
551:
1.105 misha 552: static void _at(Request& r, MethodParams& params) {
1.130 moko 553: HashStringValue& hash=GET_SELF(r, VHashBase).hash();
1.105 misha 554: size_t count=hash.count();
555:
556: int pos=0;
557:
1.121 misha 558: // misha@
559: // I do not like that type is checked before whence.
1.133 moko 560: // But I do not like the idea to move it after whence (where process can be called) even more.
1.121 misha 561: AtResultType result_type=AtResultTypeValue;
562: if(params.count() > 1) {
563: const String& stype=params.as_string(1, "type must be string");
564: if(stype == "key")
565: result_type=AtResultTypeKey;
566: else if(stype == "hash")
567: result_type=AtResultTypeHash;
568: else if(stype != "value")
569: throw Exception(PARSER_RUNTIME, &stype, "type must be 'key', 'value' or 'hash'");
570: }
571:
1.134 moko 572: Value& vwhence=params[0];
1.121 misha 573: if(vwhence.is_string()) {
1.105 misha 574: const String& swhence=*vwhence.get_string();
575: if(swhence == "last")
576: pos=count-1;
577: else if(swhence != "first")
578: throw Exception(PARSER_RUNTIME,
579: &swhence,
580: "whence must be 'first', 'last' or expression");
581: } else {
1.133 moko 582: pos=r.process(vwhence).as_int();
1.105 misha 583: if(pos < 0)
584: pos+=count;
585: }
586:
1.106 misha 587: if(count && pos >= 0 && (size_t)pos < count){
1.121 misha 588: switch(result_type) {
589: case AtResultTypeKey:
590: {
1.123 moko 591: #ifdef HASH_ORDER
1.121 misha 592: if(pos == 0) {
1.137 ! moko 593: r.write(*new VString(*new String(hash.first_key(), String::L_TAINTED)));
1.121 misha 594: } else if((size_t)pos == count-1) {
1.137 ! moko 595: r.write(*new VString(*new String(hash.last_key(), String::L_TAINTED)));
1.123 moko 596: } else
597: #endif
598: {
1.121 misha 599: for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )
600: if(!pos){
1.137 ! moko 601: r.write(*new VString(*new String(i.key(), String::L_TAINTED)));
1.121 misha 602: break;
603: }
604: }
1.105 misha 605: break;
606: }
1.121 misha 607: case AtResultTypeValue:
608: {
1.123 moko 609: #ifdef HASH_ORDER
1.121 misha 610: if(pos == 0) {
1.137 ! moko 611: r.write(*hash.first_value());
1.121 misha 612: } else if((size_t)pos == count-1) {
1.137 ! moko 613: r.write(*hash.last_value());
1.123 moko 614: } else
615: #endif
616: {
1.121 misha 617: for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )
618: if(!pos){
1.137 ! moko 619: r.write(*i.value());
1.121 misha 620: break;
621: }
622: }
623: break;
624: }
625: case AtResultTypeHash:
626: {
1.123 moko 627: #ifdef HASH_ORDER
1.121 misha 628: if(pos == 0) {
1.137 ! moko 629: r.write(SingleElementHash(hash.first_key(), hash.first_value()));
1.121 misha 630: } else if((size_t)pos == count-1) {
1.137 ! moko 631: r.write(SingleElementHash(hash.last_key(), hash.last_value()));
1.123 moko 632: } else
633: #endif
634: {
1.121 misha 635: for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )
636: if(!pos){
1.137 ! moko 637: r.write(SingleElementHash(i.key(), i.value()));
1.121 misha 638: break;
639: }
640: }
641: break;
642: }
643: }
1.105 misha 644: }
645: }
646:
1.1 paf 647: // constructor
648:
1.57 paf 649: MHash::MHash(): Methoded("hash")
1.39 paf 650: {
1.21 parser 651: // ^hash::create[[copy_from]]
1.57 paf 652: add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1);
1.22 parser 653: // ^hash.add[add_from]
1.57 paf 654: add_native_method("add", Method::CT_DYNAMIC, _create_or_add, 1, 1);
1.22 parser 655: // ^hash.sub[sub_from]
656: add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);
657: // ^a.union[b] = hash
658: add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);
659: // ^a.intersection[b] = hash
660: add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 1);
661: // ^a.intersects[b] = bool
662: add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);
1.25 paf 663:
664: // ^a.delete[key]
1.119 misha 665: add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);
1.2 parser 666:
1.82 misha 667: // ^a.contains[key]
668: add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1);
669: // backward
670: add_native_method("contain", Method::CT_DYNAMIC, _contains, 1, 1);
1.80 misha 671:
672: // ^hash::sql[query][options hash]
1.33 paf 673: add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);
1.2 parser 674:
1.68 paf 675: // ^hash._keys[[column name]]
1.124 moko 676: add_native_method("_keys", Method::CT_DYNAMIC, _keys, 0, 1);
1.16 parser 677:
678: // ^hash._count[]
1.124 moko 679: add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 0);
1.26 paf 680:
681: // ^hash.foreach[key;value]{code}[delim]
682: add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2+1, 2+1+1);
1.105 misha 683:
1.122 moko 684: // ^hash.sort[key;value]{string-key-maker}[[asc|desc]]
685: // ^hash.sort[key;value](numeric-key-maker)[[asc|desc]]
686: add_native_method("sort", Method::CT_DYNAMIC, _sort, 2+1, 2+1+1);
687:
1.121 misha 688: // ^hash._at[first|last[;'key'|'value'|'hash']]
689: // ^hash._at([-+]offset)[['key'|'value'|'hash']]
690: add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);
1.124 moko 691:
692: #ifdef FEATURE_GET_ELEMENT4CALL
693: // aliases without "_"
694: add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);
695: add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0);
696: add_native_method("at", Method::CT_DYNAMIC, _at, 1, 2);
697: #endif
698:
1.1 paf 699: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hash.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / classes