JsonSyntaxTree Class Reference

Holds the syntax in a Json::Value tree. More...

#include <JsonSyntaxTree.h>

Public Member Functions
	JsonSyntaxTree (const std::string &search_string)
virtual	~JsonSyntaxTree ()
bool	addParameters (const std::string &parent_path, const std::string &path, bool is_type, const std::string &action, bool is_action, InputParameters *params, const FileLineInfo &lineinfo, const std::string &classname)
	Add parameters to the tree. More...
void	addActionTask (const std::string &path, const std::string &action, const std::string &task, const FileLineInfo &lineinfo)
	Add a task to the tree. More...
const nlohmann::json &	getRoot () const
	Get the root of the tree. More...
void	addSyntaxType (const std::string &path, const std::string type)
	Add an associated type to a block. More...
void	addGlobal ()
	Add the global section to the output. More...

Static Public Member Functions
static std::string	basicCppType (const std::string &cpp_type)
	Utilities for making sense of c++ types. More...

Protected Member Functions
std::string	buildOptions (const std::iterator_traits< InputParameters::iterator >::value_type &p, bool &out_of_range_allowed, std::map< MooseEnumItem, std::string > &docs)
size_t	setParams (InputParameters *params, bool search_match, nlohmann::json &all_params)
nlohmann::json &	getJson (const std::string &parent, const std::string &path, bool is_type)
nlohmann::json &	getJson (const std::string &path)
std::pair< std::string, std::string >	getObjectLabel (const std::string &obj) const
std::pair< std::string, std::string >	getActionLabel (const std::string &action) const

Static Protected Member Functions
static std::string	buildOutputString (const std::iterator_traits< InputParameters::iterator >::value_type &p)
static std::vector< std::string >	splitPath (const std::string &path)

Protected Attributes
nlohmann::json	_root
std::string	_search
std::map< std::string, std::pair< std::string, std::string > >	_action_label_map
std::map< std::string, std::pair< std::string, std::string > >	_object_label_map

Friends
class	MooseServer

Detailed Description

Holds the syntax in a Json::Value tree.

Definition at line 22 of file JsonSyntaxTree.h.

Constructor & Destructor Documentation

JsonSyntaxTree()

JsonSyntaxTree::JsonSyntaxTree

(

const std::string &

search_string

)

Definition at line 29 of file JsonSyntaxTree.C.

                                                              : _search(search_string)
{
  // Registry holds a map with labels (ie MooseApp) as keys and a vector of RegistryEntry
  // as values. We need the reverse map: given an action or object name then get the label.
  auto & actmap = Registry::allActions();
  for (auto & entry : actmap)
    for (auto & act : entry.second)
      _action_label_map[act->_classname] = std::make_pair(entry.first, act->_file);

  auto & objmap = Registry::allObjects();
  for (auto & entry : objmap)
    for (auto & obj : entry.second)
      _object_label_map[obj->name()] = std::make_pair(entry.first, obj->_file);
}

~JsonSyntaxTree()

virtual JsonSyntaxTree::~JsonSyntaxTree ( )

inlinevirtual

Definition at line 26 of file JsonSyntaxTree.h.

{}

Member Function Documentation

addActionTask()

void JsonSyntaxTree::addActionTask	(	const std::string &	path,
		const std::string &	action,
		const std::string &	task,
		const FileLineInfo &	lineinfo
	)

Add a task to the tree.

Parameters

path	The path of the action
action	Name of the action
task	Name of the task
lineinfo	The FileLineInfo where the action/task was registered

Definition at line 357 of file JsonSyntaxTree.C.

Referenced by Moose::Builder::buildJsonSyntaxTree().

{
  nlohmann::json & json = getJson("", path, false);
  if (lineinfo.isValid())
    json[action]["tasks"][task_name]["file_info"][lineinfo.file()] = lineinfo.line();
}

addGlobal()

void JsonSyntaxTree::addGlobal

(

)

Add the global section to the output.

Definition at line 160 of file JsonSyntaxTree.C.

Referenced by Moose::Builder::buildJsonSyntaxTree().

{
  // If they are doing a search they probably don't want to see this
  if (_search.empty())
  {
    auto params = Moose::Builder::validParams();
    nlohmann::json jparams;
    setParams(&params, true, jparams);
    _root["global"]["parameters"] = jparams;

    // Just create a list of registered app names
    nlohmann::json apps;
    auto & factory = AppFactory::instance();
    for (const auto & name_bi_pair : factory.registeredObjects())
      apps.push_back(name_bi_pair.first);

    _root["global"]["registered_apps"] = apps;
  }
}

addParameters()

bool JsonSyntaxTree::addParameters	(	const std::string &	parent_path,
		const std::string &	path,
		bool	is_type,
		const std::string &	action,
		bool	is_action,
		InputParameters *	params,
		const FileLineInfo &	lineinfo,
		const std::string &	classname
	)

Add parameters to the tree.

Parameters

parent_path	The parent syntax path that the action belongs to
path	The path of the action
is_type	Whether this belongs to a "<type>" or not
action	Name of the action
is_action	Whether we are adding the parameter for an action (except Components)
params	The InputParameters to add to the tree
lineinfo	The FileLineInfo where the action/path was registered
classname	the name of the class being added

Returns

Whether the parameters were added to the tree (ie if it matched the search string).

Definition at line 181 of file JsonSyntaxTree.C.

Referenced by Moose::Builder::buildJsonSyntaxTree().

{
  if (action == "EmptyAction")
    return false;

  nlohmann::json all_params;
  bool search_match = !_search.empty() && (MooseUtils::wildCardMatch(path, _search) ||
                                           MooseUtils::wildCardMatch(action, _search) ||
                                           MooseUtils::wildCardMatch(parent, _search));
  auto count = setParams(params, search_match, all_params);
  if (!_search.empty() && count == 0)
    // no parameters that matched the search string
    return false;

  nlohmann::json & json = getJson(parent, path, is_type);

  if (is_action)
  {
    json[action]["parameters"] = all_params;
    json[action]["description"] = params->getClassDescription();
    json[action]["action_path"] = path;
    auto label_pair = getActionLabel(action);
    json[action]["label"] = label_pair.first;
    json[action]["register_file"] = label_pair.second;
    if (lineinfo.isValid())
      json[action]["file_info"][lineinfo.file()] = lineinfo.line();
  }
  else if (params)
  {
    if (params->hasBase())
      json["moose_base"] = params->getBase();

    json["parameters"] = all_params;
    json["syntax_path"] = path;
    json["parent_syntax"] = parent;
    json["description"] = params->getClassDescription();
    // We do this for ActionComponents which are registered as Actions but
    // dumped to the syntax tree as Objects
    if (params->hasBase() && json["moose_base"] == "Action")
    {
      auto label_pair = getActionLabel(classname);
      json["label"] = label_pair.first;
      json["register_file"] = label_pair.second;
    }
    else
    {
      auto label_pair = getObjectLabel(path);
      json["label"] = label_pair.first;
      json["register_file"] = label_pair.second;
    }
    if (lineinfo.isValid())
    {
      json["file_info"][lineinfo.file()] = lineinfo.line();
      if (!classname.empty())
        json["class"] = classname;
    }
  }
  return true;
}

addSyntaxType()

void JsonSyntaxTree::addSyntaxType	(	const std::string &	path,
		const std::string	type
	)

Add an associated type to a block.

Parameters

path	Path of the block
type	Type name to associate the block with

Definition at line 342 of file JsonSyntaxTree.C.

Referenced by Moose::Builder::buildJsonSyntaxTree().

{
  if (MooseUtils::wildCardMatch(path, _search))
  {
    auto & j = getJson(path);
    j["associated_types"].push_back(type);
  }
  // If they are doing a search they probably don't want to see this
  if (_search.empty())
  {
    _root["global"]["associated_types"][type].push_back(path);
  }
}

basicCppType()

std::string JsonSyntaxTree::basicCppType ( const std::string &  cpp_type )

static

Utilities for making sense of c++ types.

Definition at line 368 of file JsonSyntaxTree.C.

Referenced by MooseServer::addParametersToList(), MooseServer::addValuesToList(), and setParams().

{
  std::string s = "String";
  if (cpp_type.find("std::vector") != std::string::npos ||
      cpp_type.find("libMesh::VectorValue") != std::string::npos ||
      cpp_type.find("libMesh::TensorValue") != std::string::npos ||
      cpp_type.find("Eigen::Matrix") != std::string::npos)
  {
    // Get the template type and use its basic type for the array type
    pcrecpp::RE r("^[^<]+<\\s*(.*)\\s*>$");
    std::string t;
    r.FullMatch(cpp_type, &t);

    // Capture type just to the first comma for Eigen::Matrix<type,V,W,X,Y,Z>
    if (cpp_type.find("Eigen::Matrix") != std::string::npos)
      t = t.substr(0, t.find(","));

    s = "Array:" + basicCppType(t);
  }
  else if (cpp_type.find("std::map") != std::string::npos ||
           cpp_type.find("std::unordered_map") != std::string::npos)
  {
    // Get the template types
    // Matches std::map< K , V [, ...] >
    // and std::unordered_map< K , V [, ...] >
    pcrecpp::RE r_map(
        "^(?:std::)?(?:unordered_)?map\\s*<\\s*([^,>]+)\\s*,\\s*([^,>]+)(?:\\s*,.*)?\\s*>$");

    // k and v hold the key and value types
    std::string k, v;
    r_map.FullMatch(cpp_type, &k, &v);

    s = "Map:" + k + "->" + v;
  }
  else if (cpp_type.find("MultiMooseEnum") != std::string::npos ||
           cpp_type.find("ExecFlagEnum") != std::string::npos ||
           cpp_type.find("VectorPostprocessorName") != std::string::npos)
    s = "Array:String";
  else if (cpp_type.find("libMesh::Point") != std::string::npos)
    s = "Array:Real";
  else if (cpp_type == "int" || cpp_type == "unsigned int" || cpp_type == "short" ||
           cpp_type == "unsigned short" || cpp_type == "char" || cpp_type == "unsigned char" ||
           cpp_type == "long" || cpp_type == "unsigned long" || cpp_type == "long long" ||
           cpp_type == "unsigned long long")
    s = "Integer";
  else if (cpp_type == "double" || cpp_type == "float")
    s = "Real";
  else if (cpp_type == "bool")
    s = "Boolean";

  return s;
}

buildOptions()

std::string JsonSyntaxTree::buildOptions ( const std::iterator_traits< InputParameters::iterator >::value_type &  p, bool &  out_of_range_allowed, std::map< MooseEnumItem, std::string > &  docs  )

protected

Definition at line 249 of file JsonSyntaxTree.C.

Referenced by setParams().

{
  libMesh::Parameters::Value * val = MooseUtils::get(p.second);

  std::string options;
  {
    auto * enum_type = dynamic_cast<InputParameters::Parameter<MooseEnum> *>(val);
    if (enum_type)
    {
      out_of_range_allowed = enum_type->get().isOutOfRangeAllowed();
      options = enum_type->get().getRawNames();
      docs = enum_type->get().getItemDocumentation();
    }
  }
  {
    auto * enum_type = dynamic_cast<InputParameters::Parameter<MultiMooseEnum> *>(val);
    if (enum_type)
    {
      out_of_range_allowed = enum_type->get().isOutOfRangeAllowed();
      options = enum_type->get().getRawNames();
      docs = enum_type->get().getItemDocumentation();
    }
  }
  {
    auto * enum_type = dynamic_cast<InputParameters::Parameter<ExecFlagEnum> *>(val);
    if (enum_type)
    {
      out_of_range_allowed = enum_type->get().isOutOfRangeAllowed();
      options = enum_type->get().getRawNames();
      docs = enum_type->get().getItemDocumentation();
    }
  }
  {
    auto * enum_type = dynamic_cast<InputParameters::Parameter<std::vector<MooseEnum>> *>(val);
    if (enum_type)
    {
      out_of_range_allowed = (enum_type->get())[0].isOutOfRangeAllowed();
      options = (enum_type->get())[0].getRawNames();
      docs = enum_type->get()[0].getItemDocumentation();
    }
  }
  {
    auto * enum_type = dynamic_cast<InputParameters::Parameter<std::vector<MultiMooseEnum>> *>(val);
    if (enum_type)
    {
      out_of_range_allowed = (enum_type->get())[0].isOutOfRangeAllowed();
      options = (enum_type->get())[0].getRawNames();
      docs = enum_type->get()[0].getItemDocumentation();
    }
  }
  return options;
}

buildOutputString()

std::string JsonSyntaxTree::buildOutputString ( const std::iterator_traits< InputParameters::iterator >::value_type &  p )

staticprotected

Definition at line 305 of file JsonSyntaxTree.C.

Referenced by MooseServer::addParametersToList(), and setParams().

{
  libMesh::Parameters::Value * val = MooseUtils::get(p.second);

  // Account for Point
  std::stringstream str;
  InputParameters::Parameter<Point> * ptr0 = dynamic_cast<InputParameters::Parameter<Point> *>(val);

  // Account for RealVectorValues
  InputParameters::Parameter<RealVectorValue> * ptr1 =
      dynamic_cast<InputParameters::Parameter<RealVectorValue> *>(val);

  // Output the Point components
  if (ptr0)
    str << ptr0->get().operator()(0) << " " << ptr0->get().operator()(1) << " "
        << ptr0->get().operator()(2);

  // Output the RealVectorValue components
  else if (ptr1)
    str << ptr1->get().operator()(0) << " " << ptr1->get().operator()(1) << " "
        << ptr1->get().operator()(2);

  // General case, call the print operator
  else
    val->print(str);

  // remove additional '\n' possibly generated in output (breaks JSON parsing)
  std::string tmp_str = str.str();
  for (auto & ch : tmp_str)
    if (ch == '\n')
      ch = ' ';

  return tmp_str.substr(0, tmp_str.find("<RESIDUAL>"));
}

getActionLabel()

std::pair< std::string, std::string > JsonSyntaxTree::getActionLabel ( const std::string &  action ) const

protected

Definition at line 433 of file JsonSyntaxTree.C.

Referenced by addParameters().

{
  auto it = _action_label_map.find(action);
  if (it != _action_label_map.end())
    return it->second;
  else
    return std::make_pair("", "");
}

getJson() [1/2]

nlohmann::json & JsonSyntaxTree::getJson ( const std::string &  parent, const std::string &  path, bool  is_type  )

protected

Definition at line 77 of file JsonSyntaxTree.C.

Referenced by addActionTask(), addParameters(), and addSyntaxType().

{
  if (parent.empty())
  {
    auto & j = getJson(path);
    if (path.back() == '*' && !j.contains("subblock_types"))
      j["subblock_types"] = nlohmann::json();
    else if (path.back() != '*' && !j.contains("types"))
      j["types"] = nlohmann::json();
    return j["actions"];
  }

  auto & parent_json = getJson(parent);
  auto paths = splitPath(path);
  std::string key = "subblock_types";
  if (is_type)
    key = "types";
  auto & val = parent_json[key][paths.back()];
  return val;
}

getJson() [2/2]

nlohmann::json & JsonSyntaxTree::getJson ( const std::string &  path )

protected

Definition at line 57 of file JsonSyntaxTree.C.

{
  auto paths = splitPath(path);
  mooseAssert(paths.size() > 0, "path is empty");
  auto * next = &(_root["blocks"][paths[0]]);

  for (auto pit = paths.begin() + 1; pit != paths.end(); ++pit)
  {
    if (*pit == "*")
      // It has an action syntax as a parent
      next = &(*next)["star"];
    else if (*pit == "<type>")
      next = &(*next)["types"];
    else
      next = &(*next)["subblocks"][*pit];
  }
  return *next;
}

getObjectLabel()

std::pair< std::string, std::string > JsonSyntaxTree::getObjectLabel ( const std::string &  obj ) const

protected

Definition at line 422 of file JsonSyntaxTree.C.

Referenced by addParameters().

{
  auto paths = splitPath(obj);
  auto it = _object_label_map.find(paths.back());
  if (it != _object_label_map.end())
    return it->second;
  else
    return std::make_pair("", "");
}

getRoot()

const nlohmann::json& JsonSyntaxTree::getRoot ( ) const

inline

Get the root of the tree.

Returns

The top level Json::Value holding the tree.

Definition at line 64 of file JsonSyntaxTree.h.

Referenced by MooseApp::setupOptions().

{ return _root; }

setParams()

size_t JsonSyntaxTree::setParams ( InputParameters *  params, bool  search_match, nlohmann::json &  all_params  )

protected

Definition at line 99 of file JsonSyntaxTree.C.

Referenced by addGlobal(), and addParameters().

{
  size_t count = 0;
  for (auto & iter : *params)
  {
    // Make sure we want to see this parameter
    bool param_match = !_search.empty() && MooseUtils::wildCardMatch(iter.first, _search);
    if (params->isPrivate(iter.first) || (!_search.empty() && !search_match && !param_match))
      continue;

    ++count;
    nlohmann::json param_json;

    param_json["required"] = params->isParamRequired(iter.first);

    // Only output default if it has one
    if (params->isParamValid(iter.first))
      param_json["default"] = buildOutputString(iter);
    else if (params->hasDefaultCoupledValue(iter.first))
      param_json["default"] = params->defaultCoupledValue(iter.first);

    bool out_of_range_allowed = false;
    std::map<MooseEnumItem, std::string> docs;
    param_json["options"] = buildOptions(iter, out_of_range_allowed, docs);
    if (!nlohmann::to_string(param_json["options"]).empty())
    {
      param_json["out_of_range_allowed"] = out_of_range_allowed;
      if (!docs.empty())
      {
        nlohmann::json jdocs;
        for (const auto & doc : docs)
          jdocs[doc.first.name()] = doc.second;
        param_json["option_docs"] = jdocs;
      }
    }
    auto reserved_values = params->reservedValues(iter.first);
    for (const auto & reserved : reserved_values)
      param_json["reserved_values"].push_back(reserved);

    std::string t = MooseUtils::prettyCppType(params->type(iter.first));
    param_json["cpp_type"] = t;
    param_json["basic_type"] = basicCppType(t);
    param_json["group_name"] = params->getGroupName(iter.first);
    param_json["name"] = iter.first;

    std::string doc = params->getDocString(iter.first);
    MooseUtils::escape(doc);
    param_json["description"] = doc;

    param_json["doc_unit"] = params->getDocUnit(iter.first);
    param_json["doc_range"] =
        params->isRangeChecked(iter.first) ? params->rangeCheckedFunction(iter.first) : "";

    param_json["controllable"] = params->isControllable(iter.first);
    param_json["deprecated"] = params->isParamDeprecated(iter.first);
    all_params[iter.first] = param_json;
  }
  return count;
}

splitPath()

std::vector< std::string > JsonSyntaxTree::splitPath ( const std::string &  path )

staticprotected

Definition at line 45 of file JsonSyntaxTree.C.

Referenced by getJson(), and getObjectLabel().

{
  std::string s;
  std::istringstream f(path);
  std::vector<std::string> paths;
  while (std::getline(f, s, '/'))
    if (s.size() > 0)
      paths.push_back(s);
  return paths;
}

Friends And Related Function Documentation

MooseServer

friend class MooseServer

friend

Definition at line 108 of file JsonSyntaxTree.h.

Member Data Documentation

_action_label_map

std::map<std::string, std::pair<std::string, std::string> > JsonSyntaxTree::_action_label_map

protected

Maps storing action/object name to the label and file location

Definition at line 103 of file JsonSyntaxTree.h.

Referenced by getActionLabel(), and JsonSyntaxTree().

_object_label_map

std::map<std::string, std::pair<std::string, std::string> > JsonSyntaxTree::_object_label_map

protected

Definition at line 104 of file JsonSyntaxTree.h.

Referenced by getObjectLabel(), and JsonSyntaxTree().

_root

nlohmann::json JsonSyntaxTree::_root

protected

Definition at line 98 of file JsonSyntaxTree.h.

Referenced by addGlobal(), addSyntaxType(), getJson(), and getRoot().

_search

std::string JsonSyntaxTree::_search

protected

Definition at line 99 of file JsonSyntaxTree.h.

Referenced by addGlobal(), addParameters(), addSyntaxType(), and setParams().

---

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

• include/utils/JsonSyntaxTree.h
• src/utils/JsonSyntaxTree.C