Parser.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MooseTypes.h"
 
#include "hit/hit.h"
 
#include <vector>
#include <string>
#include <iomanip>
#include <optional>
#include <filesystem>
 
class FuncParseEvaler : public hit::Evaler
{
public:
  virtual std::string
  eval(hit::Field * n, const std::list<std::string> & args, hit::BraceExpander & exp);
};
 
class UnitsConversionEvaler : public hit::Evaler
{
public:
  virtual std::string
  eval(hit::Field * n, const std::list<std::string> & args, hit::BraceExpander & exp);
};
 
class EnumerateEvaler : public hit::Evaler
{
public:
  virtual std::string
  eval(hit::Field * n, const std::list<std::string> & args, hit::BraceExpander & exp);
};
 
class RangeEvaler : public hit::Evaler
{
public:
  virtual std::string
  eval(hit::Field * n, const std::list<std::string> & args, hit::BraceExpander & exp);
};
 
class RepeatEvaler : public hit::Evaler
{
public:
  virtual std::string
  eval(hit::Field * n, const std::list<std::string> & args, hit::BraceExpander & exp);
};
 
class DupParamWalker : public hit::Walker
{
public:
  virtual void
  walk(const std::string & fullpath, const std::string & /*nodepath*/, hit::Node * n) override;
 
  std::vector<hit::ErrorMessage> errors;
 
private:
  std::map<std::string, hit::Node *> _have;
};
 
class BadActiveWalker : public hit::Walker
{
public:
  virtual void walk(const std::string & /*fullpath*/,
                    const std::string & /*nodepath*/,
                    hit::Node * section) override;
  std::vector<hit::ErrorMessage> errors;
};
 
class CompileParamWalker : public hit::Walker
{
public:
  typedef std::map<std::string, hit::Node *> ParamMap;
  CompileParamWalker(ParamMap & map) : _map(map) {}
 
  virtual void
  walk(const std::string & fullpath, const std::string & /*nodepath*/, hit::Node * n) override;
 
private:
  ParamMap & _map;
};
 
class OverrideParamWalker : public hit::Walker
{
public:
  OverrideParamWalker(const CompileParamWalker::ParamMap & map) : _map(map) {}
 
  void walk(const std::string & fullpath, const std::string & /*nodepath*/, hit::Node * n) override;
  std::vector<std::string> warnings;
 
private:
  const CompileParamWalker::ParamMap & _map;
};
 
class Parser
{
public:
  Parser(const std::vector<std::string> & input_filenames,
         const std::optional<std::vector<std::string>> & input_text = {});
  Parser(const std::string & input_filename, const std::optional<std::string> & input_text = {});
 
  struct Error : public hit::Error
  {
    Error() = delete;
    Error(const std::vector<hit::ErrorMessage> & error_messages);
  };
 
  void parse();
 
  const hit::Node * queryRoot() const { return _root.get(); }
  hit::Node * queryRoot() { return _root.get(); }
 
  hit::Node & getRoot();
 
  const hit::Node * queryCommandLineRoot() const { return _cli_root.get(); }
  hit::Node * queryCommandLineRoot() { return _cli_root.get(); }
 
  const hit::Node & getCommandLineRoot() const;
  hit::Node & getCommandLineRoot();
 
  const std::vector<std::string> & getInputFileNames() const { return _input_filenames; }
 
  const std::vector<std::string> & getInputText() const { return _input_text; }
 
  /*
   * Get extracted application type from parser
   */
  const std::string & getAppType() const { return _app_type; }
 
  /*
   * Set the application type in parser
   */
  void setAppType(const std::string & app_type) { _app_type = app_type; }
 
  void setCommandLineParams(const std::vector<std::string> & params);
 
  const std::string & getLastInputFileName() const;
 
  std::filesystem::path getLastInputFilePath() const { return getLastInputFileName(); }
 
  void setThrowOnError(const bool throw_on_error) { _throw_on_error = throw_on_error; }
 
  bool getThrowOnError() const { return _throw_on_error; }
 
  const std::set<std::string> & getExtractedVars() const { return _extracted_vars; }
  static void appendErrorMessages(std::vector<hit::ErrorMessage> & to,
                                  const std::vector<hit::ErrorMessage> & from);
  static void appendErrorMessages(std::vector<hit::ErrorMessage> & to, const hit::Error & error);
 
  static std::string joinErrorMessages(const std::vector<hit::ErrorMessage> & error_messages);
 
  void parseError(std::vector<hit::ErrorMessage> messages) const;
 
private:
  std::unique_ptr<hit::Node> _root;
 
  const std::vector<std::string> _input_filenames;
 
  std::vector<std::string> _input_text;
 
  std::unique_ptr<hit::Node> _cli_root;
 
  std::string _app_type;
 
  bool _throw_on_error;
 
  std::optional<std::vector<std::string>> _command_line_params;
 
  std::set<std::string> _extracted_vars;
};