InputParser.hh

Go to the documentation of this file.

#ifndef CASM_InputParser
#define CASM_InputParser
 
#include <boost/filesystem.hpp>
#include <map>
#include <memory>
#include <set>
#include <string>
 
#include "casm/casm_io/json/jsonParser.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/Validator.hh"
 
namespace CASM {
 
class Log;
 
struct KwargsParser : public Validator {
  jsonParser const &input;
 
  fs::path path;
 
  jsonParser const &self;
 
  bool required;
 
  std::string type_name;
 
  KwargsParser(jsonParser const &_input, fs::path _path, bool _required);
 
  virtual ~KwargsParser() {}
 
  // --- Accessing the JSON `input` ---
 
  const jsonParser &parent() const;
 
  fs::path parent_path() const;
 
  std::string name() const;
 
  bool exists() const;
 
  fs::path relpath(const fs::path &val) const {
    return path.empty() ? val : path / val;
  }
 
  // --- Subparsers ---
 
  typedef std::multimap<fs::path, std::shared_ptr<KwargsParser>> map_type;
 
  map_type::const_iterator begin() const;
 
  map_type::const_iterator end() const;
 
  bool valid() const;
 
  std::map<fs::path, std::set<std::string>> all_warnings() const;
 
  std::map<fs::path, std::set<std::string>> all_errors() const;
 
  using Validator::insert;
 
  void insert(fs::path path, const std::shared_ptr<KwargsParser> &subparser);
 
  void insert_error(fs::path option, std::string message);
 
  void insert_warning(fs::path option, std::string message);
 
  bool warn_unnecessary(const std::set<std::string> &expected);
 
 private:
  typedef map_type::value_type PairType;
 
  map_type m_subparsers;
};
 
template <typename T>
class InputParser : public KwargsParser {
 public:
  std::unique_ptr<T> value;
 
  template <typename... Args>
  InputParser(jsonParser const &_input, Args &&... args);
 
  template <typename... Args>
  InputParser(jsonParser const &_input, fs::path _path, bool _required,
              Args &&... args);
 
  template <typename CustomParse>
  InputParser(CustomParse f_parse, jsonParser const &_input);
 
  template <typename CustomParse>
  InputParser(CustomParse f_parse, jsonParser const &_input, fs::path _path,
              bool _required);
 
  template <typename RequiredType, typename... Args>
  std::unique_ptr<RequiredType> require(fs::path option, Args &&... args);
 
  template <typename RequiredType, typename... Args>
  void require(RequiredType &value, fs::path option, Args &&... args);
 
  template <typename RequiredType, typename... Args>
  std::unique_ptr<RequiredType> optional(fs::path option, Args &&... args);
 
  template <typename RequiredType, typename... Args>
  void optional(RequiredType &value, fs::path option, Args &&... args);
 
  template <typename RequiredType, typename... Args>
  RequiredType optional_else(fs::path option, const RequiredType &_default,
                             Args &&... args);
 
  template <typename RequiredType, typename... Args>
  void optional_else(RequiredType &value, fs::path option,
                     const RequiredType &_default, Args &&... args);
 
  template <typename RequiredType, typename... Args>
  std::shared_ptr<InputParser<RequiredType>> subparse(fs::path option,
                                                      Args &&... args);
 
  template <typename RequiredType, typename... Args>
  std::shared_ptr<InputParser<RequiredType>> subparse_if(fs::path option,
                                                         Args &&... args);
 
  template <typename RequiredType, typename... Args>
  std::shared_ptr<InputParser<RequiredType>> subparse_else(
      fs::path option, const RequiredType &_default, Args &&... args);
 
  template <typename RequiredType, typename... Args>
  std::shared_ptr<InputParser<RequiredType>> parse_as(Args &&... args);
};
 
class ParentInputParser : public InputParser<std::nullptr_t> {
 public:
  std::shared_ptr<jsonParser const> parent_input;
 
  ParentInputParser(jsonParser const &input)
      : ParentInputParser(std::make_shared<jsonParser const>(input)) {}
 
  ParentInputParser(std::shared_ptr<jsonParser const> _parent_input)
      : InputParser<std::nullptr_t>(*_parent_input),
        parent_input(_parent_input) {}
};
 
int parse_verbosity(KwargsParser &parser, int default_verbosity = 10);
 
void parse(InputParser<std::nullptr_t> &parser);
 
template <typename T>
void parse(InputParser<T> &parser);
 
// --- Methods for formatting error and warning messages ---
 
void print_warnings(KwargsParser const &parser, Log &log,
                    std::string header = "Warnings");
 
void print_errors(KwargsParser const &parser, Log &log,
                  std::string header = "Errors");
 
jsonParser make_report(KwargsParser const &parser);
 
template <typename ErrorType>
void report_and_throw_if_invalid(KwargsParser const &parser, Log &log,
                                 ErrorType error);
 
}  // namespace CASM
 
#endif