Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F86150337
colvarparse.h
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Fri, Oct 4, 14:20
Size
7 KB
Mime Type
text/x-c++
Expires
Sun, Oct 6, 14:20 (2 d)
Engine
blob
Format
Raw Data
Handle
21353526
Attached To
rLAMMPS lammps
colvarparse.h
View Options
#ifndef COLVARPARSE_H
#define COLVARPARSE_H
#include <cstring>
#include <string>
#include "colvarmodule.h"
#include "colvarvalue.h"
/// \file colvarparse.h Parsing functions for collective variables
/// \brief Base class containing parsing functions; all objects which
/// need to parse input inherit from this
class colvarparse {
protected:
/// \brief List of legal keywords for this object: this is updated
/// by each call to colvarparse::get_keyval() or
/// colvarparse::key_lookup()
std::list<std::string> allowed_keywords;
/// \brief 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_begin_pos;
/// \brief 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;
/// \brief 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)
bool save_delimiters;
/// \brief Add a new valid keyword to the list
void add_keyword (char const *key);
/// \brief Remove all the values from the config string
void strip_values (std::string &conf);
public:
inline colvarparse()
: save_delimiters (true)
{}
/// How a keyword is parsed in a string
enum Parse_Mode {
/// \brief (default) Read the first instance of a keyword (if
/// any), report its value, and print a warning when there is more
/// than one
parse_normal,
/// \brief Like parse_normal, but don't send any message to the log
/// (useful e.g. in restart files when such messages are very
/// numerous and redundant)
parse_silent
};
/// \fn get_keyval bool const get_keyval (std::string const &conf,
/// char const *key, _type_ &value, _type_ const &def_value,
/// Parse_Mode const parse_mode) \brief Helper function to parse
/// keywords in the configuration and get their values
///
/// In normal circumstances, you should use either version the
/// get_keyval function. Both of them look for the C string "key"
/// in the C++ string "conf", and assign the corresponding value (if
/// available) to the variable "value" (first version), or assign as
/// many values as found to the vector "values" (second version).
///
/// If "key" is found but no value is associated to it, the default
/// value is provided (either one copy or as many copies as the
/// current length of the vector "values" specifies). A message
/// will print, unless parse_mode is equal to parse_silent. The
/// return value of both forms of get_keyval is true if "key" is
/// found (with or without value), and false when "key" is absent in
/// the string "conf". If there is more than one instance of the
/// keyword, a warning will be raised; instead, to loop over
/// multiple instances key_lookup() should be invoked directly.
///
/// If you introduce a new data type, add two new instances of this
/// functions, or insert this type in the \link colvarvalue \endlink
/// wrapper class (colvarvalue.h).
#define _get_keyval_scalar_proto_(_type_,_def_value_) \
bool get_keyval (std::string const &conf, \
char const *key, \
_type_ &value, \
_type_ const &def_value = _def_value_, \
Parse_Mode const parse_mode = parse_normal)
_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);
#define _get_keyval_vector_proto_(_type_,_def_value_) \
bool get_keyval (std::string const &conf, \
char const *key, \
std::vector<_type_> &values, \
std::vector<_type_> const &def_values = \
std::vector<_type_> (0, static_cast<_type_>(_def_value_)), \
Parse_Mode const parse_mode = parse_normal)
_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));
/// \brief 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
void check_keywords (std::string &conf, char const *key);
/// \brief Return a lowercased copy of the string
static inline std::string to_lower_cppstr (std::string const &in)
{
std::string out = "";
for (size_t i = 0; i < in.size(); i++) {
out.append (1, (char) ::tolower (in[i]) );
}
return out;
}
/// \brief Helper class to read a block of the type "key { ... }"
/// from a stream and store it in a string
///
/// Useful on restarts, where the file is too big to be loaded in a
/// string by key_lookup; it can only check that the keyword is
/// correct and the block is properly delimited by braces, not
/// skipping other blocks
class read_block {
std::string const key;
std::string * const data;
public:
inline read_block (std::string const &key_in, std::string &data_in)
: key (key_in), data (&data_in)
{}
inline ~read_block() {}
friend std::istream & operator >> (std::istream &is, read_block const &rb);
};
/// Accepted white space delimiters, used in key_lookup()
static std::string const white_space;
/// \brief Low-level function for parsing configuration strings;
/// automatically adds the requested keywords to the list of valid
/// ones. \param conf the content of the configuration file or one
/// of its blocks \param key the keyword to search in "conf" \param
/// data (optional) holds the string provided after "key", if any
/// \param save_pos (optional) stores the position of the keyword
/// within "conf", useful when doing multiple calls \param
/// save_delimiters (optional)
bool key_lookup (std::string const &conf,
char const *key,
std::string &data = dummy_string,
size_t &save_pos = dummy_pos);
/// Used as a default argument by key_lookup
static std::string dummy_string;
/// Used as a default argument by key_lookup
static size_t dummy_pos;
/// \brief Works as std::getline() but also removes everything
/// between a comment character and the following newline
static std::istream & getline_nocomments (std::istream &is,
std::string &s,
char const delim = '\n');
/// Check if the content of the file has matching braces
bool brace_check (std::string const &conf,
size_t const start_pos = 0);
};
#endif
// Emacs
// Local Variables:
// mode: C++
// End:
Event Timeline
Log In to Comment