[BACK]Return to array.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/array.C between versions 1.2 and 1.8

version 1.2, 2024/09/10 20:48:15 version 1.8, 2024/09/22 13:56:09
Line 33  public: Line 33  public:
   
 DECLARE_CLASS_VAR(array, new MArray);  DECLARE_CLASS_VAR(array, new MArray);
   
   const char* const PARAM_ARRAY_OR_HASH = "param must be array or hash";
   const char* const PARAM_INDEX = "index must be integer";
   
 // methods  // methods
   
 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_ARRAY_OR_HASH);
                 VArray& self=GET_SELF(r, VArray);                  VArray& self=GET_SELF(r, VArray);
                 ArrayValue& self_array=self.array();                  ArrayValue& self_array=self.array();
   
                 if(VArray* src=static_cast<VArray*>(vsrc.as(VARRAY_TYPE))) {                  if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
                         ArrayValue& src_array =src->array();                          if(src==&self)
                         if(&src_array==&self_array) // same: doing nothing                                  throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");
                                 return;                          self_array.append(src->array());
                 } else {                  } else {
                         HashStringValue* src_hash=vsrc.get_hash();                          HashStringValue* src_hash=vsrc.get_hash();
                         if(src_hash)                          if(!src_hash)
                                 for(HashStringValue::Iterator i(*src_hash); i; i.next())                                  return;
                           for(HashStringValue::Iterator i(*src_hash); i; i.next()){
                                   self_array.put(VArray::index(i.key()), i.value());
                           }
                   }
                   self.invalidate();
           }
   }
   
   static ArrayValue::Action_options get_action_options(Request& r, MethodParams& params, size_t options_index) {
           ArrayValue::Action_options result;
           if(params.count() <= options_index)
                   return result;
   
           HashStringValue* options=params.as_hash(options_index);
           if(!options)
                   return result;
   
           result.defined=true;
           int valid_options=0;
   
           if(Value* voffset=options->get(sql_offset_name)) {
                   valid_options++;
                   int offset=r.process(*voffset).as_int();
                   result.offset=offset < 0 ? 0 : offset;
           }
           if(Value* vlimit=options->get(sql_limit_name)) {
                   valid_options++;
                   int limit=r.process(*vlimit).as_int();
                   result.limit=limit < 0 ? 0: limit;
           }
   
           if(valid_options!=options->count())
                   throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
   
           return result;
   }
   
   static void _join(Request& r, MethodParams& params) {
           Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH);
           ArrayValue::Action_options o=get_action_options(r, params, 1);
   
           VArray& self=GET_SELF(r, VArray);
           ArrayValue& self_array=self.array();
   
           if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
                   if(src==&self)
                           throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");
   
                   if(o.defined){
                           for(ArrayValue::Iterator i(src->array()); i; i.next()){
                                   if(i.value()){
                                           if(o.offset > 0){
                                                   o.offset--;
                                                   continue;
                                           }
                                           if(o.limit-- == 0)
                                                   break;
                                         self_array+=i.value();                                          self_array+=i.value();
                                   }
                           }
                   } else {
                           for(ArrayValue::Iterator i(src->array()); i; i.next()){
                                   if(i.value())
                                           self_array+=i.value();
                           }
                   }
           } else {
                   HashStringValue* src_hash=vsrc.get_hash();
                   if(!src_hash)
                           return;
                   if(o.defined){
                           for(HashStringValue::Iterator i(*src_hash); i; i.next()){
                                   if(o.offset > 0){
                                           o.offset--;
                                           continue;
                                   }
                                   if(o.limit-- == 0)
                                           break;
                                   self_array+=i.value();
                           }
                   } else {
                           for(HashStringValue::Iterator i(*src_hash); i; i.next()){
                                   self_array+=i.value();
                           }
                 }                  }
                 self.clear_hash();  
         }          }
           self.invalidate();
 }  }
   
 static void _sql(Request& r, MethodParams& params) {}  static void _sql(Request& r, MethodParams& params) {}
Line 88  static void _keys(Request& r, MethodPara Line 174  static void _keys(Request& r, MethodPara
         r.write(*new VTable(table));          r.write(*new VTable(table));
 }  }
   
 static void _count(Request& r, MethodParams&) {  static void _count(Request& r, MethodParams& params) {
         r.write(*new VInt(GET_SELF(r, VArray).count()));          ArrayValue& array=GET_SELF(r, VArray).array();
           if(params.count()>0){
                   const String& what=params.as_string(0, PARAMETER_MUST_BE_STRING);
                   if(!what.is_empty()){
                           if(what != "all")
                                   throw Exception(PARSER_RUNTIME, &what, "param must be empty or 'all'");
                           return r.write(*new VInt(array.count()));
                   }
           }
           r.write(*new VInt(array.used()));
 }  }
   
 static void _append(Request& r, MethodParams& params) {  static void _append(Request& r, MethodParams& params) {
Line 101  static void _append(Request& r, MethodPa Line 196  static void _append(Request& r, MethodPa
         for(int i=0; i<count; i++){          for(int i=0; i<count; i++){
                 array+=&r.process(params[i]);                  array+=&r.process(params[i]);
         }          }
         self.clear_hash();          self.invalidate();
 }  }
   
 static void _insert(Request& r, MethodParams& params) {  static void _insert(Request& r, MethodParams& params) {
Line 109  static void _insert(Request& r, MethodPa Line 204  static void _insert(Request& r, MethodPa
         ArrayValue& array=self.array();          ArrayValue& array=self.array();
   
         int count=params.count();          int count=params.count();
         size_t index=VArray::index(params.as_int(0, "index must be integer", r));          size_t index=VArray::index(params.as_int(0, PARAM_INDEX, r));
   
         for(int i=1; i<count; i++){          for(int i=1; i<count; i++){
                 array.insert(index+i-1, &r.process(params[i]));                  array.insert(index++, &r.process(params[i]));
         }          }
         self.clear_hash();          self.invalidate();
 }  }
   
 static void _delete(Request& r, MethodParams& params) {  static void _delete(Request& r, MethodParams& params) {
           VArray& self=GET_SELF(r, VArray);
         if(params.count()>0)          if(params.count()>0)
                 GET_SELF(r, VArray).clear(VArray::index(params.as_int(0, "index must be integer", r)));                  self.array().clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));
         else          else
                 GET_SELF(r, VArray).clear();                  self.array().clear();
           self.invalidate();
   }
   
   static void _remove(Request& r, MethodParams& params) {
           VArray& self=GET_SELF(r, VArray);
           self.array().remove(VArray::index(params.as_int(0, PARAM_INDEX, r)));
           self.invalidate();
 }  }
   
 static void _contains(Request& r, MethodParams& params) {  static void _contains(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          VArray& self=GET_SELF(r, VArray);
         bool result=self.contains(VArray::index(params.as_int(0, "index must be integer", r)));          bool result=self.contains(VArray::index(params.as_int(0, PARAM_INDEX, r)));
         r.write(VBool::get(result));          r.write(VBool::get(result));
 }  }
   
   static void _for(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* body_code=&params.as_junction(2, "body must be code");
           Value* delim_maybe_code=params.count()>3 ? &params[3] : 0;
           Value& caller=*r.get_method_frame()->caller();
   
           if(key_var_name->is_empty()) key_var_name=0;
           if(value_var_name->is_empty()) value_var_name=0;
   
           ArrayValue& array=GET_SELF(r, VArray).array();
   
           if(delim_maybe_code){ // delimiter set
                   bool need_delim=false;
                   for(ArrayValue::Iterator i(array); i; i.next()){
                           if(key_var_name){
                                   VString* vkey=new VString(*new String(i.key(), String::L_TAINTED));
                                   r.put_element(caller, *key_var_name, vkey);
                           }
   
                           if(value_var_name)
                                   r.put_element(caller, *value_var_name, i.value() ? i.value() : VVoid::get());
   
                           Value& sv_processed=r.process(*body_code);
                           TempSkip4Delimiter skip(r);
   
                           const String* s_processed=sv_processed.get_string();
                           if(s_processed && !s_processed->is_empty()) { // we have body
                                   if(need_delim) // need delim & iteration produced string?
                                           r.write(r.process(*delim_maybe_code));
                                   else
                                           need_delim=true;
                           }
   
                           r.write(sv_processed);
   
                           if(skip.check_break())
                                   break;
                   }
           } else {
                   for(ArrayValue::Iterator i(array); i; i.next()){
                           if(key_var_name){
                                   VString* vkey=new VString(*new String(i.key(), String::L_TAINTED));
                                   r.put_element(caller, *key_var_name, vkey);
                           }
   
                           if(value_var_name)
                                   r.put_element(caller, *value_var_name, i.value() ? i.value() : VVoid::get());
   
                           r.process_write(*body_code);
   
                           if(r.check_skip_break())
                                   break;
                   }
           }
   }
   
 static void _foreach(Request& r, MethodParams& params) {  static void _foreach(Request& r, MethodParams& params) {
         InCycle temp(r);          InCycle temp(r);
   
         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[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;
Line 193  static void _foreach(Request& r, MethodP Line 355  static void _foreach(Request& r, MethodP
         }          }
 }  }
   
   
 enum AtResultType {  
         AtResultTypeValue = 0,  
         AtResultTypeKey = 1,  
         AtResultTypeHash = 2  
 };  
   
 inline Value& SingleElementHash(String::Body akey, Value* avalue) {  
         Value& result=*new VHash;  
         result.put_element(*new String(akey, String::L_TAINTED), avalue);  
         return result;  
 }  
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct Array_seq_item : public PA_Allocated {  struct Array_seq_item : public PA_Allocated {
         Value *array_data;          Value *array_data;
Line 245  static void _sort(Request& r, MethodPara Line 394  static void _sort(Request& r, MethodPara
   
         VArray& self=GET_SELF(r, VArray);          VArray& self=GET_SELF(r, VArray);
         ArrayValue& array=self.array();          ArrayValue& array=self.array();
         int count=self.count(); // not array.count()          int count=array.used(); // not array.count()
   
         Array_seq_item* seq=new Array_seq_item[count];          Array_seq_item* seq=new Array_seq_item[count];
         int pos=0;          int pos=0;
Line 291  static void _sort(Request& r, MethodPara Line 440  static void _sort(Request& r, MethodPara
         delete[] seq;          delete[] seq;
 }  }
   
   enum AtResultType {
           AtResultTypeValue = 0,
           AtResultTypeKey = 1,
           AtResultTypeHash = 2
   };
   
   inline Value& SingleElementHash(String::Body akey, Value* avalue) {
           Value& result=*new VHash;
           result.put_element(*new String(akey, String::L_TAINTED), avalue);
           return result;
   }
   
 static void _at(Request& r, MethodParams& params) {  static void _at(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          VArray& self=GET_SELF(r, VArray);
         ArrayValue& array=self.array();          ArrayValue& array=self.array();
         size_t count=self.count();          size_t count=array.used(); // not array.count()
   
         int pos=0;          int pos=0;
   
Line 393  static void _select(Request& r, MethodPa Line 554  static void _select(Request& r, MethodPa
         ArrayValue& result_array=result->array();          ArrayValue& result_array=result->array();
   
         if(limit>0){          if(limit>0){
   
                 if(reverse){                  if(reverse){
                         for(ArrayValue::ReverseIterator i(source_array); i; ){                          for(ArrayValue::ReverseIterator i(source_array); i; ){
                                 Value *value=i.prev(); // here for correct i.key()                                  if(Value *value=i.prev()){ // here for correct i.key()
                                 if(key_var_name)                                          if(key_var_name)
                                         r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED)));                                                  r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED)));
                                 if(value_var_name)                                          if(value_var_name)
                                         r.put_element(caller, *value_var_name, value);                                                  r.put_element(caller, *value_var_name, value);
   
                                 bool condition=r.process(vcondition).as_bool();  
   
                                 if(r.check_skip_break())                                          bool condition=r.process(vcondition).as_bool();
                                         break;  
   
                                 if(condition){                                          if(r.check_skip_break())
                                         result_array+=value;  
                                         if(!--limit)  
                                                 break;                                                  break;
   
                                           if(condition){
                                                   result_array+=value;
                                                   if(!--limit)
                                                           break;
                                           }
                                 }                                  }
                         }                          }
                 } else {                  } else {
                         for(ArrayValue::Iterator i(source_array); i; i.next() ){                          for(ArrayValue::Iterator i(source_array); i; i.next() ){
                                 Value *value=i.value();                                  if(Value *value=i.value()){
                                 if(value){  
                                         if(key_var_name)                                          if(key_var_name)
                                                 r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED)));                                                  r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED)));
                                         if(value_var_name)                                          if(value_var_name)
Line 441  static void _select(Request& r, MethodPa Line 601  static void _select(Request& r, MethodPa
 }  }
   
 static void _reverse(Request& r, MethodParams& params) {  static void _reverse(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          ArrayValue& source_array=GET_SELF(r, VArray).array();
         ArrayValue& source_array=self.array();  
         size_t count=source_array.count();  
   
         VArray& result=*new VArray(count);          VArray& result=*new VArray(source_array.count());
         ArrayValue& result_array=result.array();          ArrayValue& result_array=result.array();
   
         for(ArrayValue::Iterator i(source_array); i; ){          for(ArrayValue::ReverseIterator i(source_array); i; ){
                 Value *v=i.next();                  result_array+=i.prev();
                 if(v){  
                         result_array.fit(count-i.index() /* no -1 as .next() is called */, v);  
                 }  
         }          }
   
         r.write(result);          r.write(result);
 }  }
   
   
 static void _rename(Request& r, MethodParams& params) {}  
   
 // constructor  // constructor
   
 MArray::MArray(): Methoded(VARRAY_TYPE) {  MArray::MArray(): Methoded(VARRAY_TYPE) {
 //      set_base(hash_class);  
   
         // ^array::create[[copy_from]]          // ^array::create[[copy_from]]
         add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1);          add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1);
         // ^array.add[add_from]          // ^array.add[add_from]
         add_native_method("add", Method::CT_DYNAMIC, _create_or_add, 1, 1);          add_native_method("add", Method::CT_DYNAMIC, _create_or_add, 1, 1);
           // ^array.join[join_from[;options]]
           add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2);
   
         // ^array.sub[sub_from]          // ^array.sub[sub_from]
         add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);          add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);
Line 480  MArray::MArray(): Methoded(VARRAY_TYPE) Line 634  MArray::MArray(): Methoded(VARRAY_TYPE)
         // ^array.intersects[b] = bool          // ^array.intersects[b] = bool
         add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);          add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);
   
           // ^array::new[value;value]
           add_native_method("new", Method::CT_DYNAMIC, _append, 0, 10000);
         // ^array.append[value;value]          // ^array.append[value;value]
         add_native_method("append", Method::CT_DYNAMIC, _append, 1, 10000);          add_native_method("append", Method::CT_DYNAMIC, _append, 1, 10000);
   
         // ^array.insert[index;value...]          // ^array.insert[index;value...]
         add_native_method("insert", Method::CT_DYNAMIC, _insert, 2, 10000);          add_native_method("insert", Method::CT_DYNAMIC, _insert, 2, 10000);
   
         // ^array.delete[index]          // ^array.delete[index]
         add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);          add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);
           // ^array.remove[index]
           add_native_method("remove", Method::CT_DYNAMIC, _remove, 1, 1);
   
         // ^array.contains[index]          // ^array.contains[index]
         add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1);          add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1);
Line 498  MArray::MArray(): Methoded(VARRAY_TYPE) Line 655  MArray::MArray(): Methoded(VARRAY_TYPE)
         // ^array._keys[[column name]]          // ^array._keys[[column name]]
         add_native_method("_keys", Method::CT_DYNAMIC, _keys, 0, 1);          add_native_method("_keys", Method::CT_DYNAMIC, _keys, 0, 1);
   
         // ^array._count[]          // ^array._count[[all]]
         add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 0);          add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 1);
   
           // ^array.for[index;value]{code}[delim]
           add_native_method("for", Method::CT_DYNAMIC, _for, 3, 3+1);
         // ^array.foreach[index;value]{code}[delim]          // ^array.foreach[index;value]{code}[delim]
         add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2+1, 2+1+1);          add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 3, 3+1);
   
         // ^array.sort[index;value]{string-key-maker}[[asc|desc]]          // ^array.sort[index;value]{string-key-maker}[[asc|desc]]
         // ^array.sort[index;value](numeric-key-maker)[[asc|desc]]          // ^array.sort[index;value](numeric-key-maker)[[asc|desc]]
Line 518  MArray::MArray(): Methoded(VARRAY_TYPE) Line 677  MArray::MArray(): Methoded(VARRAY_TYPE)
         // ^array._at([-+]offset)[['key'|'value'|'hash']]          // ^array._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);
   
         // ^array.rename[from;to]  
         // ^array.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);
Removed from v.1.2  
changed lines
  Added in v.1.8

E-mail: