colvarparse.h

Go to the documentation of this file.

#ifndef COLVARPARSE_H
#define COLVARPARSE_H

#include <cstring>
#include <string>

#include "colvarmodule.h"
#include "colvarvalue.h"




class colvarparse {

protected:

  std::list<std::string> allowed_keywords;

  std::list<size_t>      data_begin_pos;

  std::list<size_t>      data_end_pos;

  bool save_delimiters;

  void add_keyword (char const *key);

  void strip_values (std::string &conf);

public:

  inline colvarparse()
    : save_delimiters (true)
  {}

  enum Parse_Mode { 
    parse_normal, 
    parse_silent 
  };


#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));


  void check_keywords (std::string &conf, char const *key);


  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;
  }

  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);
  };


  static std::string const white_space;

  bool key_lookup (std::string const &conf,
                   char const *key,
                   std::string &data = dummy_string,
                   size_t &save_pos = dummy_pos);

  static std::string dummy_string;
  static size_t dummy_pos;

  static std::istream & getline_nocomments (std::istream &is,
                                            std::string &s,
                                            char const delim = '\n');

  bool brace_check (std::string const &conf,
                    size_t const start_pos = 0);

};


#endif

// Emacs
// Local Variables:
// mode: C++
// End:

---