valueparser.c

robocup rcssmonitor-11.1.1.zip

    value[i]= tmp_long;

    value_str= error_ptr;
  }
  while (*value_str == ' ') value_str++;
  if (*value_str != '\0')
    warning= true;

  return len;
}

int str_to_long_array(bool & warning,const char* value_str,long* value,int len) {
  if (!value_str) return -1;
  if (strlen(value_str)==0) {
    if (len > 0) warning= true;
    return 0;
  }

  char* error_ptr;
  long tmp_long;
  ////////
  for (int i=0; i< len; i++) {
    while (*value_str == ' ') value_str++;
    if (*value_str == '\0') {
      warning= true;
      return i;
    }

    tmp_long= strtol(value_str, &error_ptr, 10);

    if (*error_ptr != '\0' && *error_ptr != ' ') {
      warning= true;
      return i;
    }
    else if (ERANGE == errno) {
      warning= true;
      return i;
    }

    value[i]= tmp_long;

    value_str= error_ptr;
  }
  while (*value_str == ' ') value_str++;
  if (*value_str != '\0')
    warning= true;
  return len;
}

int  str_to_float_array(bool & warning,const char* value_str,float* value,int len) {
  if (!value_str) return -1;
  if (strlen(value_str)==0) {
    if (len > 0) warning= true;
    return 0;
  }

  char* error_ptr;
  double tmp_double;

  for (int i=0; i< len; i++) {
    while (*value_str == ' ') value_str++;
    if (*value_str == '\0') {
      warning= true;
      return i;
    }

    tmp_double= strtod(value_str, &error_ptr);

    if (*error_ptr != '\0' && *error_ptr != ' ') {
      warning= true;
      return i;
    }
    else if (ERANGE == errno) {
      warning= true;
      return i;
    }

    value[i]= float(tmp_double);

    value_str= error_ptr;
  }
  while (*value_str == ' ') value_str++;
  if (*value_str != '\0')
    warning= true;
  return len;
}

int  str_to_double_array(bool & warning,const char* value_str,double* value,int len) {
  if (!value_str) return -1;
  if (strlen(value_str)==0) {
    if (len > 0) warning= true;
    return 0;
  };

  char* error_ptr;
  double tmp_double;

  for (int i=0; i< len; i++) {
    while (*value_str == ' ') value_str++;
    if (*value_str == '\0') {
      warning= true;
      return i;
    }

    tmp_double= strtod(value_str, &error_ptr);

    if (*error_ptr != '\0' && *error_ptr != ' ') {
      warning= true;
      return i;
    }
    else if (ERANGE == errno) {
      warning= true;
      return i;
    }

    value[i]= tmp_double;

    value_str= error_ptr;
  }
  while (*value_str == ' ') value_str++;
  if (*value_str != '\0')
    warning= true;
  return len;
}

int str_to_bool_array(bool & warning,const char* value_str,bool* value,int len) {
  if (!value_str) return -1;
  if (strlen(value_str)==0) {
    if (len>0) warning= true;
    return 0;
  }

  int i;
  bool tmp_bool;
  for (i=0; i< len; i++) {
    while (*value_str == ' ' )
      value_str++;
    if (*value_str == '\0') {
      warning= true;
      return i;
    }

    if (strncmp("true",value_str,4)==0) {
      value_str+= 4;
      tmp_bool = true;
    }
    else if (strncmp("false",value_str,5)==0) {
      value_str+= 5;
      tmp_bool= false;
    }
    else {
      char *error_ptr= 0;
      long tmp_long = strtol(value_str, &error_ptr, 10);
      if ( tmp_long != 1 && tmp_long != 0) {
	warning= true;
      }
      tmp_bool= bool(tmp_long);
      value_str= error_ptr;
    }
    if ( *value_str == '\0' || *value_str == ' ') {
      value[i]= tmp_bool;
    }
    else {
      warning= true;
      return i;
    }
  }
  return len;
}

int str_to_char_array(bool & warning,const char* value_str,char* value,int len) {
  if (!value_str) return -1;
  int dum= strlen(value_str);
  if (dum == 0) {
    if (len!= 0) warning= true;
    return 0;
  }
  for (int i=0; i<len; i++) {
    if (i> dum) {
      //warning= true; keien Warnung, falls String kuerzer als angegeben (nur bei char arrays)
      return i;
    }
    value[i]= value_str[i];
  }
  if (len <= dum) warning= true; // Warnung, falls String laenger als angegeben
  return len;
}

int ValueParser::getValue(const char * key,int type,void* value,int arr_length) const {
  const char* value_str= 0;
  int  value_str_len= 0;
  int key_idx= -1;
  bool warning= false;
  int read_entries= -1;

  for (int idx= kv_tab.cur_size-1; idx >= 0; idx--) {
    KeyValueTab::Entry * entry= kv_tab.tab+idx;
    if ( entry->key == 0) {
      cerr << "\nat index " << idx << " a zero key entry";
      continue;
    }
    if ( strcmp(key,entry->key) != 0 )
      continue;

    entry->access += 1;
    if (key_idx < 0)
      key_idx= idx;
    else {
      cout << "\nignoring because of multiple definition:"
	   << "\n    "
	   << setw(max_key_length) << setiosflags(ios::left)
	   << key << " = ["
	   << entry->val << "]";
      entry= kv_tab.tab+key_idx;
      cout << "\n   and using (last definition):"
	   << "   [" << entry->val << "]";
    }
  }

  if (key_idx<0) {
    if ((warnings_mode || verbose_mode))
      cout <<  "\nkey= " << key << "   WARNING: NO SUCH ENTRY WAS FOUND";
    return read_entries;
  }

  value_str= kv_tab.tab[key_idx].val;
  value_str_len = 0;
  if (value_str) value_str_len= strlen(value_str);

  if (0 == value_str_len && arr_length != 0 && type!= type_string)
    warning= true;

  switch (type) {
  case type_int:
    read_entries= str_to_int_array(warning,value_str,(int*)value,arr_length);
    break;
  case type_long:
    read_entries= str_to_long_array(warning,value_str,(long*)value,arr_length);
    break;
  case type_float:
    read_entries= str_to_float_array(warning,value_str,(float*)value,arr_length);
    break;
  case type_double:
    read_entries= str_to_double_array(warning,value_str,(double*)value,arr_length);
    break;
#if 0
  case type_string:
    if (0==value_str_len)
      break;
    *((string*) value)=values[i];
    break;
#endif
  case type_bool:
    read_entries= str_to_bool_array(warning,value_str,(bool*)value,arr_length);
    break;
  case type_char:
    read_entries= str_to_char_array(warning,value_str,(char*)value,arr_length);
    break;
  }

  if (read_entries < 0)
    read_entries= 0; //the key was there, so the minimum of options is 0

  if ( warning && warnings_mode || verbose_mode) {
    cout << "\nentry: res= " << read_entries;
    showValue(key,type,value,arr_length);
    if (warning && warnings_mode)
      cout <<  "   WARNING: read from  [" << value_str << "]";
  }

  return read_entries;
}

void ValueParser::showValue(const char * key,int type,void* value,int arr_length) const {
  cout << "\n    "
       << setw(max_key_length) << setiosflags(ios::left)
       << key << " = [";

  for (int i=0; i<arr_length; i++) {
    //cout << " ";
    bool stop= false;
    switch (type) {
    case type_int:
      cout << ((int*) value)[i];
      if (i<arr_length-1) cout << " ";
      break;
    case type_long:
      cout << ((long*) value)[i];
      if (i<arr_length-1) cout << " ";
      break;
    case type_float:
      cout << ((float*) value)[i];
      if (i<arr_length-1) cout << " ";
      break;
    case type_double:
      cout << ((double*) value)[i];
      if (i<arr_length-1) cout << " ";
      break;
#if 0
    case type_string:
      cout << *((string*) value);
      break;
#endif
    case type_bool:
      if ( ((bool*)value)[i] )
	cout << "true";
      else
	cout << "false";
      if (i<arr_length-1) cout << " ";
      break;
    case type_char:
      if ( ((char*) value)[i] == '\0') {
	cout << "\\0";
	stop= true;
      }
      cout << ((char*) value)[i];
      break;
    default: cout << "unknown";
    }
    if (stop)
      break;
  }
  cout << "]";
}



/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
/******************************* T E S T *************************************/
#if 0

void test() {
  const int maxLineLength= 1024;
  const char fname[]= "test.txt";
  ifstream is(fname);
  if (!is) {
    cerr << "\nCannot open control file" << fname;
    exit(1);
    //return;
  }

  char line[maxLineLength+1];

  char fun[20];
  int size;
  int rand;
  double err;

  while (is) {
    is.getline(line,maxLineLength);
    const char * dum= line;
    while ( isspace(*dum) )
      dum++;

    if ( *dum == '\0' || *dum == '#' ) //comment or blank line
      continue;

    ValueParser vp(0,line);

    vp.get("fun",fun,20);
    vp.get("size",size, -1);
    vp.get("rand",rand,-1);
    int res= vp.get("err",err);
    if (res != 1 || size < 0 || rand < 0) {
      cerr << "\nerrornous line [" << line << "]";
    }
    else
      cout << "\n" << fun << " | " << size << " | " << rand << " -> " << err;
  }
  cout << endl;
}

int main (int argc,char **argv) {
  test(); return 0;

  KeyValueTab st;
  st.set_cur_size(20);
  st.set_key(0,"bla");
  //return 1;

  //ValueParser P(argv[1],argv[2]);
  //ValueParser P(argc-1,argv+1);//,"d1_");
  //ValueParser P("vp.test","BLOCK");
  if (argc< 2) {
    cout << "\nneed one argument";
    return 1;
  }
  ValueParser P(0,argv[1]);
  P.set_verbose(true);
  cout << P;
  bool h;
  P.get("help",h);

  //int i;
  bool b_arr[4];
  int i_arr[4];
  long l_arr[4];
  char c_arr[4];
  char c2_arr[4];
  float f_arr[4];
  double d_arr[4];

  int res;

  res= P.get("l",l_arr,4,-100);
  cout << "\n res= " << res << "\n----------";
  res= P.get("b",b_arr,4,false);
  cout << "\n res= " << res << "\n----------";
  res= P.get("c",c_arr,4,'\0');
  cout << "\n res= " << res << "\n----------";
  res= P.get("c2",c2_arr,4,"123");
  cout << "\n res= " << res << "\n----------";
  res= P.get("i",i_arr,4,-100);
  cout << "\n res= " << res << "\n----------";
  res= P.get("f",f_arr,4,-100.11);
  cout << "\n res= " << res << "\n----------";
  res= P.get("d",d_arr,4,-100.55);
  cout << "\n res= " << res << "\n----------";

  cout << endl;

  P.show_not_accessed_entries(cerr);
  cerr << "\nnumber of accessed entries= " << P.num_of_accessed_entries() << endl;
  return 0;
}

#endif