NAMD: colvarparse Class Reference

Low-level function for parsing configuration strings; automatically adds the requested keywords to the list of valid ones.

00408 {
00409   // add this keyword to the register (in its camelCase version)
00410   add_keyword (key_in);
00411 
00412   // use the lowercase version from now on
00413   std::string const key (to_lower_cppstr (key_in));
00414 
00415   // "conf_lower" is only used to lookup the keyword, but its value
00416   // will be read from "conf", in order not to mess up file names
00417   std::string const conf_lower (to_lower_cppstr (conf));
00418 
00419   // by default, there is no value, unless we found one
00420   data = "";
00421 
00422   // when the function is invoked without save_pos, ensure that we
00423   // start from zero
00424   colvarparse::dummy_pos = 0;
00425 
00426   // start from the first occurrence of key
00427   size_t pos = conf_lower.find (key, save_pos); 
00428   
00429   // iterate over all instances until it finds the isolated keyword
00430   while (true) {
00431 
00432     if (pos == std::string::npos) {
00433       // no valid instance of the keyword has been found
00434       return false;
00435     }
00436 
00437     bool b_isolated_left = true, b_isolated_right = true;
00438 
00439     if (pos > 0) {
00440       if ( std::string ("\n"+white_space+
00441                         "}").find (conf[pos-1]) ==
00442            std::string::npos ) {
00443         // none of the valid delimiting characters is on the left of key 
00444         b_isolated_left = false;
00445       }
00446     }
00447 
00448     if (pos < conf.size()-key.size()-1) {
00449       if ( std::string ("\n"+white_space+
00450                         "{").find (conf[pos+key.size()]) ==
00451            std::string::npos ) {
00452         // none of the valid delimiting characters is on the right of key 
00453         b_isolated_right = false;
00454       }
00455     }
00456 
00457     // check that there are matching braces between here and the end of conf
00458     bool const b_not_within_block = brace_check (conf, pos);
00459 
00460     bool const b_isolated = (b_isolated_left && b_isolated_right &&
00461                              b_not_within_block);
00462     
00463     if (b_isolated) {
00464       // found it
00465       break;
00466     } else {
00467       // try the next occurrence of key
00468       pos = conf_lower.find (key, pos+key.size());
00469     }
00470   }
00471 
00472   // check it is not between quotes
00473   //   if ( (conf.find_last_of  ("\"",
00474   //                             conf.find_last_of  (white_space, pos)) !=
00475   //         std::string::npos) &&
00476   //        (conf.find_first_of ("\"",
00477   //                             conf.find_first_of (white_space, pos)) !=
00478   //         std::string::npos) )
00479   //     return false;
00480 
00481 
00482   // save the pointer for a future call (when iterating over multiple
00483   // valid instances of the same keyword)
00484   save_pos = pos + key.size();
00485 
00486   // get the remainder of the line
00487   size_t pl = conf.rfind ("\n", pos);
00488   size_t line_begin = (pl == std::string::npos) ? 0 : pos;
00489   size_t nl = conf.find  ("\n", pos);
00490   size_t line_end = (nl == std::string::npos) ? conf.size() : nl;
00491   std::string line (conf, line_begin, (line_end-line_begin)); 
00492 
00493   size_t data_begin = (to_lower_cppstr (line)).find (key) + key.size();
00494   data_begin = line.find_first_not_of (white_space, data_begin+1);
00495 
00496   //   size_t data_begin_absolute = data_begin + line_begin;
00497   //   size_t data_end_absolute   = data_begin;
00498 
00499   if (data_begin != std::string::npos) {
00500 
00501     size_t data_end = line.find_last_not_of (white_space) + 1;
00502     data_end = (data_end == std::string::npos) ? line.size() : data_end;
00503     //     data_end_absolute = data_end + line_begin;
00504 
00505     if (line.find ('{', data_begin) != std::string::npos) {
00506 
00507       size_t brace_count = 1;
00508       size_t brace = line.find ('{', data_begin);  // start from the first opening brace
00509 
00510       while (brace_count > 0) {
00511 
00512         // find the matching closing brace
00513         brace = line.find_first_of ("{}", brace+1);
00514         while (brace == std::string::npos) {
00515           // add a new line
00516           if (line_end >= conf.size()) {
00517             cvm::fatal_error ("Parse error: reached the end while "
00518                               "looking for closing brace; until now "
00519                               "the following was parsed: \"\n"+
00520                               line+"\".\n");
00521             return false;
00522           }
00523           size_t const old_end = line.size();
00524           //           data_end_absolute += old_end+1;
00525 
00526           line_begin = line_end;
00527           nl = conf.find ('\n', line_begin+1);
00528           if (nl == std::string::npos) 
00529             line_end = conf.size();
00530           else 
00531             line_end = nl;
00532           line.append (conf, line_begin, (line_end-line_begin));
00533 
00534           brace = line.find_first_of ("{}", old_end);
00535         }
00536 
00537         if (line[brace] == '{') brace_count++;
00538         if (line[brace] == '}') brace_count--;
00539       }
00540 
00541       // set data_begin afterthe opening brace
00542       data_begin = line.find_first_of ('{', data_begin) + 1;
00543       data_begin = line.find_first_not_of (white_space,
00544                                            data_begin);
00545       // set data_end before the closing brace
00546       data_end = brace;
00547       data_end = line.find_last_not_of (white_space+"}",
00548                                         data_end) + 1;
00549       //       data_end_absolute = line_end;
00550 
00551       if (data_end > line.size())
00552         data_end = line.size();
00553     }
00554 
00555     data.append (line, data_begin, (data_end-data_begin));
00556 
00557     if (data.size() && save_delimiters) {
00558       data_begin_pos.push_back (conf.find (data, pos+key.size()));
00559       data_end_pos.push_back   (data_begin_pos.back()+data.size());
00560       //       std::cerr << "key = " << key << ", data = \""
00561       //                 << data << "\", data_begin, data_end = "
00562       //                 << data_begin_pos.back() << ", " << data_end_pos.back()
00563       //                 << "\n";
00564     }
00565   }
00566   
00567   save_pos = line_end;
00568 
00569   return true;
00570 }


Public Types
enum	Parse_Mode { parse_normal, parse_silent }
	How a keyword is parsed in a string. More...
Public Member Functions
	colvarparse ()
	_get_keyval_scalar_proto_ (int,(int) 0)
	_get_keyval_scalar_proto_ (size_t,(size_t) 0)
	_get_keyval_scalar_proto_ (std::string, std::string(""))
	_get_keyval_scalar_proto_ (cvm::real,(cvm::real) 0.0)
	_get_keyval_scalar_proto_ (cvm::rvector, cvm::rvector())
	_get_keyval_scalar_proto_ (cvm::quaternion, cvm::quaternion())
	_get_keyval_scalar_proto_ (colvarvalue, colvarvalue(colvarvalue::type_notset))
	_get_keyval_scalar_proto_ (bool, false)
	_get_keyval_vector_proto_ (int, 0)
	_get_keyval_vector_proto_ (size_t, 0)
	_get_keyval_vector_proto_ (std::string, std::string(""))
	_get_keyval_vector_proto_ (cvm::real, 0.0)
	_get_keyval_vector_proto_ (cvm::rvector, cvm::rvector())
	_get_keyval_vector_proto_ (cvm::quaternion, cvm::quaternion())
	_get_keyval_vector_proto_ (colvarvalue, colvarvalue(colvarvalue::type_notset))
void	check_keywords (std::string &conf, char const *key)
	Check that all the keywords within "conf" are in the list of allowed keywords; this will invoke strip_values() first and then loop over all words.
bool	key_lookup (std::string const &conf, char const *key, std::string &data=dummy_string, size_t &save_pos=dummy_pos)
	Low-level function for parsing configuration strings; automatically adds the requested keywords to the list of valid ones.
bool	brace_check (std::string const &conf, size_t const start_pos=0)
	Check if the content of the file has matching braces.
Static Public Member Functions
std::string	to_lower_cppstr (std::string const &in)
	Return a lowercased copy of the string.
std::istream &	getline_nocomments (std::istream &is, std::string &s, char const delim= '\n')
	Works as std::getline() but also removes everything between a comment character and the following newline.
Static Public Attributes
std::string const	white_space = " \t"
	Accepted white space delimiters, used in key_lookup().
std::string	dummy_string = ""
	Used as a default argument by key_lookup.
size_t	dummy_pos = 0
	Used as a default argument by key_lookup.
Protected Member Functions
void	add_keyword (char const *key)
	Add a new valid keyword to the list.
void	strip_values (std::string &conf)
	Remove all the values from the config string.
Protected Attributes
std::list< std::string >	allowed_keywords
	List of legal keywords for this object: this is updated by each call to colvarparse::get_keyval() or colvarparse::key_lookup().
std::list< size_t >	data_begin_pos
	List of delimiters for the values of each keyword in the configuration string; all keywords will be stripped of their values before the keyword check is performed.
std::list< size_t >	data_end_pos
	List of delimiters for the values of each keyword in the configuration string; all keywords will be stripped of their values before the keyword check is performed.
bool	save_delimiters
	Whether or not to accumulate data_begin_pos and data_end_pos in key_lookup(); it may be useful to disable this after the constructor is called, because other files may be read (e.g. restart) that would mess up with the registry; in any case, nothing serious happens until check_keywords() is invoked (which should happen only right after construction).

colvarparse Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation