colvarparse.h

Go to the documentation of this file.

// -*- c++ -*-
 
// This file is part of the Collective Variables module (Colvars).
// The original version of Colvars and its updates are located at:
// https://github.com/Colvars/colvars
// Please update all Colvars source files before making any changes.
// If you wish to distribute your changes, please submit them to the
// Colvars repository at GitHub.
 
#ifndef COLVARPARSE_H
#define COLVARPARSE_H
 
#include <cstring>
#include <list>
#include <string>
 
#include "colvarmodule.h"
#include "colvarvalue.h"
#include "colvarparams.h"
 
 
 
 
class colvarparse : public colvarparams {
 
public:
 
  colvarparse();
 
  colvarparse(const std::string& conf);
 
  void clear();
 
  void set_string(std::string const &conf);
 
  ~colvarparse() override;
 
  inline std::string const & get_config() const
  {
    return config_string;
  }
 
  enum Parse_Mode {
    parse_null = 0,
    parse_echo = (1<<1),
    parse_echo_default = (1<<2),
    parse_deprecation_warning = (1<<3),
    parse_silent = 0,
    parse_required = (1<<16),
    parse_override = (1<<17),
    parse_restart = (1<<18),
    parse_normal = (1<<1) | (1<<2) | (1<<17),
    parse_deprecated = (1<<1) | (1<<3) | (1<<17)
  };
 
  int check_keywords(std::string &conf, char const *key);
 
  void clear_keyword_registry();
 
 
  bool get_keyval(std::string const &conf,
                  char const *key,
                  int &value,
                  int const &def_value = 0,
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  size_t &value,
                  size_t const &def_value = 0,
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  long &value,
                  long const &def_value = 0,
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  cvm::step_number &value,
                  cvm::step_number const &def_value = 0,
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::string &value,
                  std::string const &def_value = std::string(""),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  cvm::real &value,
                  cvm::real const &def_value = 0.0,
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  cvm::rvector &value,
                  cvm::rvector const &def_value = cvm::rvector(),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  cvm::quaternion &value,
                  cvm::quaternion const &def_value = cvm::quaternion(),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  colvarvalue &value,
                  colvarvalue const &def_value = colvarvalue(colvarvalue::type_notset),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  bool &value,
                  bool const &def_value = false,
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<int> &values,
                  std::vector<int> const &def_values = std::vector<int>(0, 0),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<size_t> &values,
                  std::vector<size_t> const &def_values = std::vector<size_t>(0, 0),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<long> &values,
                  std::vector<long> const &def_values = std::vector<long>(0, 0),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<std::string> &values,
                  std::vector<std::string> const &def_values = std::vector<std::string>(0, std::string("")),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<cvm::real> &values,
                  std::vector<cvm::real> const &def_values = std::vector<cvm::real>(0, 0.0),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<cvm::rvector> &values,
                  std::vector<cvm::rvector> const &def_values = std::vector<cvm::rvector>(0, cvm::rvector()),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<cvm::quaternion> &values,
                  std::vector<cvm::quaternion> const &def_values = std::vector<cvm::quaternion>(0, cvm::quaternion()),
                  Parse_Mode const parse_mode = parse_normal);
  bool get_keyval(std::string const &conf,
                  char const *key,
                  std::vector<colvarvalue> &values,
                  std::vector<colvarvalue> const &def_values = std::vector<colvarvalue>(0, colvarvalue(colvarvalue::type_notset)),
                  Parse_Mode const parse_mode = parse_normal);
 
protected:
 
  bool get_key_string_value(std::string const &conf,
                            char const *key, std::string &data);
 
  bool get_key_string_multi_value(std::string const &conf,
                                  char const *key, std::vector<std::string>& data);
 
  template<typename TYPE>
  bool _get_keyval_scalar_(std::string const &conf,
                           char const *key,
                           TYPE &value,
                           TYPE const &def_value,
                           Parse_Mode const &parse_mode);
 
  template<typename TYPE>
  bool _get_keyval_vector_(std::string const &conf,
                           char const *key,
                           std::vector<TYPE> &values,
                           std::vector<TYPE> const &def_values,
                           Parse_Mode const &parse_mode);
 
  template<typename TYPE>
  int _get_keyval_scalar_value_(std::string const &key_str,
                                std::string const &data,
                                TYPE &value,
                                TYPE const &def_value);
 
  template<typename TYPE>
  int _get_keyval_scalar_novalue_(std::string const &key_str,
                                  TYPE &value,
                                  Parse_Mode const &parse_mode);
 
  template<typename TYPE>
  void mark_key_set_user(std::string const &key_str,
                         TYPE const &value,
                         Parse_Mode const &parse_mode);
 
  template<typename TYPE>
  void mark_key_set_default(std::string const &key_str,
                            TYPE const &def_value,
                            Parse_Mode const &parse_mode);
 
  void error_key_required(std::string const &key_str,
                          Parse_Mode const &parse_mode);
 
  bool key_already_set(std::string const &key_str);
 
public:
 
  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, static_cast<char>( ::tolower(in[i])) );
    }
    return out;
  }
 
  class read_block {
  public:
 
    read_block(std::string const &key, std::string *data = nullptr);
 
    ~read_block();
 
    friend std::istream & operator >> (std::istream &is, read_block const &rb);
 
    friend cvm::memory_stream & operator >> (cvm::memory_stream &is, read_block const &rb);
 
  private:
 
    std::string const key;
 
    std::string * const data;
 
    std::istream & read_block_contents(std::istream &is, bool block_only = false) const;
  };
 
 
  static const char * const white_space;
 
  bool key_lookup(std::string const &conf,
                  char const *key,
                  std::string *data = nullptr,
                  size_t *save_pos = nullptr);
 
  std::istream & read_config_line(std::istream &is, std::string &line);
 
  static std::istream & getline_nocomments(std::istream &is, std::string &s);
 
  static int check_braces(std::string const &conf, size_t const start_pos);
 
  static int check_ascii(std::string const &conf);
 
  static void split_string(const std::string& data, const std::string& delim, std::vector<std::string>& dest);
 
protected:
 
  std::string const keyword_delimiters_left;
 
  std::string const keyword_delimiters_right;
 
  std::list<std::string> allowed_keywords;
 
  enum key_set_mode {
    key_not_set = 0,
    key_set_user = 1,
    key_set_default = 2
  };
 
  std::map<std::string, key_set_mode> key_set_modes;
 
  std::list<size_t>      data_begin_pos;
 
  std::list<size_t>      data_end_pos;
 
  void add_keyword(char const *key);
 
  void strip_values(std::string &conf);
 
  std::string config_string;
 
};
 
 
inline colvarparse::Parse_Mode operator | (colvarparse::Parse_Mode const &mode1,
                                           colvarparse::Parse_Mode const &mode2)
{
  return static_cast<colvarparse::Parse_Mode>(static_cast<int>(mode1) |
                                              static_cast<int>(mode2));
}
 
#endif