JsonInputFileFormatter Class Reference

This class produces produces a dump of the InputParameters that appears like the normal input file syntax. More...

#include <JsonInputFileFormatter.h>

Public Member Functions
	JsonInputFileFormatter ()
std::string	toString (const nlohmann::json &root)
	Returns a string representation of the tree in input file format.

Protected Member Functions
void	addLine (const std::string &line, size_t max_line_len=0, const std::string &comment="")
	Adds a line to the output.
void	addBlock (const std::string &name, const nlohmann::json &block, bool top=false)
	Adds a new block to the output.
void	addParameters (const nlohmann::json &params)
	Add a comment to the block.
void	addTypes (const std::string &key, const nlohmann::json &block)
	Add a dictionary of type blocks to the output.

Protected Attributes
const int	_spaces
int	_level
std::ostringstream	_stream

Detailed Description

This class produces produces a dump of the InputParameters that appears like the normal input file syntax.

It is different from InputFileFormatter in that it takes its input from JsonSyntaxTree.

Definition at line 20 of file JsonInputFileFormatter.h.

Constructor & Destructor Documentation

JsonInputFileFormatter()

JsonInputFileFormatter::JsonInputFileFormatter

(

)

Definition at line 16 of file JsonInputFileFormatter.C.

: _spaces(2), _level(0) {}

Member Function Documentation

addBlock()

void JsonInputFileFormatter::addBlock ( const std::string &  name, const nlohmann::json &  block, bool  top = false  )

protected

Adds a new block to the output.

Parameters

name	Name of the block.
block	Json holding data for the block.
top	Whether this is a top level block.

Definition at line 73 of file JsonInputFileFormatter.C.

{
  addLine("");
  if (toplevel)
    addLine("[" + name + "]");
  else
    addLine("[./" + name + "]");
 
  _level++;
  std::string desc = block.contains("description") ? nlohmann::to_string(block["description"]) : "";
  if (!desc.empty())
    addLine("", 0, desc);
 
  if (block.contains("parameters"))
    addParameters(block["parameters"]);
 
  if (block.contains("actions"))
  {
    // there could be duplicate parameters across actions, last one wins
    nlohmann::json all_params;
    auto & actions = block["actions"];
    for (auto && el : actions.items())
    {
      auto & params = el.value()["parameters"];
      for (auto && param_el : params.items())
        all_params[param_el.key()] = param_el.value();
    }
    addParameters(all_params);
  }
 
  if (block.contains("star"))
    addBlock("*", block["star"]);
 
  addTypes("subblock_types", block);
  addTypes("types", block);
 
  if (block.contains("subblocks"))
  {
    auto & subblocks = block["subblocks"];
    if (!subblocks.is_null())
      for (auto && el : subblocks.items())
        addBlock(el.key(), el.value());
  }
 
  _level--;
  if (toplevel)
    addLine("[]");
  else
    addLine("[../]");
}

Referenced by addBlock(), addTypes(), and toString().

addLine()

void JsonInputFileFormatter::addLine ( const std::string &  line, size_t  max_line_len = 0, const std::string &  comment = ""  )

protected

Adds a line to the output.

This will put in the proper indentation automatically.

Parameters

line	The line to add.
max_line_len	Used to determine where to start inline comments. @comment comment Comment to add to the line. It will automatically be broken up over multiple lines if too long.

Definition at line 29 of file JsonInputFileFormatter.C.

{
  if (line.empty() && comment.empty())
  {
    _stream << "\n";
    return;
  }
 
  std::string indent(_level * _spaces, ' ');
  auto doc = MooseUtils::trim(comment);
  if (doc.empty()) // Not comment so just print out the line normally
  {
    _stream << indent << line << "\n";
    return;
  }
 
  // We have a comment so we need to break it up over multiple lines if necessary
  // and make sure that they all start at the same spot.
  _stream << indent << line;
  std::vector<std::string> elements;
 
  // if the line is empty we can just start the comment right away
  int extra = 1;
  if (line.empty())
    extra = 0;
 
  // be careful of really long lines.
  int len = 100 - max_line_len - indent.size();
  if (len < 0)
    len = 20;
 
  MooseUtils::tokenize(doc, elements, len, " \t");
  std::string first(max_line_len - line.size() + extra, ' ');
  _stream << first << "# " << elements[0] << "\n";
  std::string cindent(max_line_len + indent.size() + extra, ' ');
  for (size_t i = 1; i < elements.size(); ++i)
    _stream << cindent << "# " << elements[i] << "\n";
 
  _stream << std::flush;
}

Referenced by addBlock(), addParameters(), and addTypes().

addParameters()

void JsonInputFileFormatter::addParameters ( const nlohmann::json &  params )

protected

Add a comment to the block.

It will add the proper indentation and #.

Parameters

comment

The comment to add.

Definition at line 145 of file JsonInputFileFormatter.C.

{
  size_t max_name = 0;
  for (auto & el : params.items())
    if (el.key().size() > max_name)
      max_name = el.key().size();
 
  size_t max_len = 0;
  std::map<std::string, std::string> lines;
  for (auto && el : params.items())
  {
    auto & name = el.key();
    auto & param = el.value();
    auto def =
        param.contains("default") ? MooseUtils::trim(nlohmann::to_string(param["default"])) : "";
    if (!def.empty())
      def = def.substr(1, def.size() - 2);
    if (def.find(' ') != std::string::npos)
      def = "'" + def + "'";
    std::string indent(max_name - name.size(), ' ');
    std::string required;
    if (param["required"])
      required = "(required)";
    if (def.size() == 0 && required.size() == 0)
      def = "(no_default)";
    std::string l = name + indent + " = " + def + required;
    if (l.size() > max_len)
      max_len = l.size();
    lines[name] = l;
  }
  for (auto & el : params.items())
  {
    auto & name = el.key();
    auto & param = el.value();
    auto & l = lines[name];
    auto desc = nlohmann::to_string(param["description"]);
    addLine(l, max_len, desc);
 
    const auto cpp_type = param.contains("cpp_type") ? param["cpp_type"].get<std::string>() : "";
    const bool is_moose_enum = cpp_type.find("MooseEnum") != std::string::npos ||
                               cpp_type.find("ExecFlagEnum") != std::string::npos;
 
    if (is_moose_enum)
    {
      const auto options_string = MooseUtils::trim(param["options"].get<std::string>());
      if (!options_string.empty())
      {
        std::vector<std::string> options;
        MooseUtils::tokenize(options_string, options, 1, " ");
        addLine("", max_len + 1, "Options: " + MooseUtils::join(options, ", "));
 
        if (param.contains("option_docs") && param["option_docs"].is_object())
          for (const auto & option : options)
          {
            const auto option_doc_key = MooseUtils::toUpper(option);
            if (param["option_docs"].contains(option_doc_key))
              addLine("",
                      max_len + 1,
                      option + ": " + param["option_docs"][option_doc_key].get<std::string>());
          }
      }
    }
 
    const auto doc_unit = nlohmann::to_string(param["doc_unit"]);
    if (!doc_unit.empty())
      addLine("", max_len + 1,
              "Unit: " + doc_unit); // a +1 to account for an empty line
 
    const auto group = nlohmann::to_string(param["group_name"]);
    if (!group.empty())
      addLine("", max_len + 1,
              "Group: " + group); // a +1 to account for an empty line
  }
}

Referenced by addBlock().

addTypes()

void JsonInputFileFormatter::addTypes ( const std::string &  key, const nlohmann::json &  block  )

protected

Add a dictionary of type blocks to the output.

Parameters

key	This will be used to get the dictionary of types from block.
block	The Json data that is the parent of the types data.

Definition at line 127 of file JsonInputFileFormatter.C.

{
  if (!block.contains(key))
    return;
  auto & types = block[key];
  if (types.is_null())
    return;
 
  addLine("");
  addLine("[./<types>]");
  _level++;
  for (auto && el : types.items())
    addBlock("<" + el.key() + ">", el.value());
  _level--;
  addLine("[../]");
}

Referenced by addBlock().

toString()

std::string JsonInputFileFormatter::toString

(

const nlohmann::json &

root

)

Returns a string representation of the tree in input file format.

Parameters

root	The root node of the tree to output.

Definition at line 19 of file JsonInputFileFormatter.C.

{
  _stream.clear();
  _stream.str("");
  for (auto && el : root["blocks"].items())
    addBlock(el.key(), el.value(), true);
  return _stream.str();
}

Referenced by MooseApp::setupOptions().

Member Data Documentation

_level

int JsonInputFileFormatter::_level

protected

Definition at line 63 of file JsonInputFileFormatter.h.

Referenced by addBlock(), addLine(), and addTypes().

_spaces

const int JsonInputFileFormatter::_spaces

protected

Definition at line 62 of file JsonInputFileFormatter.h.

Referenced by addLine().

_stream

std::ostringstream JsonInputFileFormatter::_stream

protected

Definition at line 64 of file JsonInputFileFormatter.h.

Referenced by addLine(), and toString().

---

The documentation for this class was generated from the following files:

• include/outputs/formatters/JsonInputFileFormatter.h
• src/outputs/formatters/JsonInputFileFormatter.C