Builder.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

// MOOSE includes
#include "ConsoleStreamInterface.h"
#include "MooseTypes.h"
#include "InputParameters.h"
#include "Syntax.h"
#include "Parser.h"

#include "hit/hit.h"

#include <vector>
#include <string>
#include <iomanip>
#include <optional>

// Forward declarations
class ActionWarehouse;
class SyntaxTree;
class MooseApp;
class Factory;
class ActionFactory;
class GlobalParamsAction;
class JsonSyntaxTree;

namespace Moose
{
class Builder;

class UnusedWalker : public hit::Walker
{
public:
  UnusedWalker(std::set<std::string> used, Builder & p) : _used(used), _builder(p) {}

  void walk(const std::string & fullpath, const std::string & nodename, hit::Node * n) override;

  std::vector<std::string> errors;

private:
  std::set<std::string> _used;
  Builder & _builder;
};

class Builder : public ConsoleStreamInterface, public hit::Walker
{
public:
  enum SyntaxFormatterType
  {
    INPUT_FILE,
    YAML
  };

  Builder(MooseApp & app, ActionWarehouse & action_wh, std::shared_ptr<Parser> parser);
  virtual ~Builder();

  static InputParameters validParams();

  std::string getPrimaryFileName(bool stripLeadingPath = true) const;

  void build();

  void extractParams(const std::string & prefix, InputParameters & p);

  void initSyntaxFormatter(SyntaxFormatterType type, bool dump_mode);

  void buildFullTree(const std::string & search_string);

  void buildJsonSyntaxTree(JsonSyntaxTree & tree) const;

  void walk(const std::string & fullpath, const std::string & nodepath, hit::Node * n);

  void errorCheck(const libMesh::Parallel::Communicator & comm, bool warn_unused, bool err_unused);

  std::vector<std::string> listValidParams(std::string & section_name);

  hit::Node * root();

protected:
  template <typename T, typename Base>
  void setScalarParameter(const std::string & full_name,
                          const std::string & short_name,
                          InputParameters::Parameter<T> * param,
                          bool in_global,
                          GlobalParamsAction * global_block);

  template <typename T, typename UP_T, typename Base>
  void setScalarValueTypeParameter(const std::string & full_name,
                                   const std::string & short_name,
                                   InputParameters::Parameter<T> * param,
                                   bool in_global,
                                   GlobalParamsAction * global_block);

  template <typename T, typename Base>
  void setVectorParameter(const std::string & full_name,
                          const std::string & short_name,
                          InputParameters::Parameter<std::vector<T>> * param,
                          bool in_global,
                          GlobalParamsAction * global_block);

  template <typename KeyType, typename MappedType>
  void setMapParameter(const std::string & full_name,
                       const std::string & short_name,
                       InputParameters::Parameter<std::map<KeyType, MappedType>> * param,
                       bool in_global,
                       GlobalParamsAction * global_block);

  template <typename T>
  void setDoubleIndexParameter(const std::string & full_name,
                               const std::string & short_name,
                               InputParameters::Parameter<std::vector<std::vector<T>>> * param,
                               bool in_global,
                               GlobalParamsAction * global_block);

  template <typename T>
  void setTripleIndexParameter(
      const std::string & full_name,
      const std::string & short_name,
      InputParameters::Parameter<std::vector<std::vector<std::vector<T>>>> * param,
      bool in_global,
      GlobalParamsAction * global_block);

  template <typename T>
  void setScalarComponentParameter(const std::string & full_name,
                                   const std::string & short_name,
                                   InputParameters::Parameter<T> * param,
                                   bool in_global,
                                   GlobalParamsAction * global_block);

  template <typename T>
  void setVectorComponentParameter(const std::string & full_name,
                                   const std::string & short_name,
                                   InputParameters::Parameter<std::vector<T>> * param,
                                   bool in_global,
                                   GlobalParamsAction * global_block);

  template <typename T>
  void
  setVectorVectorComponentParameter(const std::string & full_name,
                                    const std::string & short_name,
                                    InputParameters::Parameter<std::vector<std::vector<T>>> * param,
                                    bool in_global,
                                    GlobalParamsAction * global_block);

  std::unique_ptr<hit::Node> _cli_root = nullptr;
  hit::Node * _root;
  std::vector<std::string> _secs_need_first;

  MooseApp & _app;
  Factory & _factory;
  ActionWarehouse & _action_wh;
  ActionFactory & _action_factory;
  Syntax & _syntax;
  const std::shared_ptr<Parser> _parser;

  std::unique_ptr<SyntaxTree> _syntax_formatter;

  std::set<std::string> _extracted_vars;

  bool _sections_read;

  InputParameters * _current_params;

  std::ostringstream * _current_error_stream;

  std::unordered_set<std::string> _deprec_param_tracker;

private:
  std::string _errmsg;
  std::string _warnmsg;
  void walkRaw(std::string fullpath, std::string nodepath, hit::Node * n);
};
}