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 332 of file JsonSyntaxTree.C.

{
  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 155 of file JsonSyntaxTree.C.

{
  // 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	Wheter it is an action
params	The InputParameters to add to the tree
lineinfo	The FileLineInfo where the action/path was registered

Returns

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

Definition at line 176 of file JsonSyntaxTree.C.

{
  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->isParamValid("_moose_base"))
      json["moose_base"] = params->get<std::string>("_moose_base");

    json["parameters"] = all_params;
    json["syntax_path"] = path;
    json["parent_syntax"] = parent;
    json["description"] = params->getClassDescription();
    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 317 of file JsonSyntaxTree.C.

{
  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 343 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("MultiMooseEnum") != std::string::npos ||
           cpp_type.find("ExecFlagEnum") != std::string::npos ||
           cpp_type.find("VectorPostprocessorName") != std::string::npos ||
           cpp_type.find("std::map") != 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 233 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();
    }
  }
  return options;
}

buildOutputString()

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

staticprotected

Definition at line 280 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 394 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 383 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 63 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["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 107 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 102 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 103 of file JsonSyntaxTree.h.

Referenced by getObjectLabel(), and JsonSyntaxTree().

_root

nlohmann::json JsonSyntaxTree::_root

protected

Definition at line 97 of file JsonSyntaxTree.h.

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

_search

std::string JsonSyntaxTree::_search

protected

Definition at line 98 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