SyntaxTree::TreeNode Class Reference

This class represents a single node in our tree. More...

#include <SyntaxTree.h>

Public Member Functions
	TreeNode (const std::string &name, SyntaxTree &syntax_tree, const std::string *action=NULL, InputParameters *params=NULL, TreeNode *parent=NULL)
	~TreeNode ()
void	insertNode (std::string &syntax, const std::string &action, bool is_action_params=true, InputParameters *params=NULL)
std::string	print (short depth, const std::string &search_string, bool &found)
std::string	getLongName (const std::string &delim="/") const

Protected Member Functions
void	insertParams (const std::string &action, bool is_action_params, InputParameters *params=NULL)

Protected Attributes
std::map< std::string, std::unique_ptr< TreeNode > >	_children
std::multimap< std::string, std::unique_ptr< InputParameters > >	_action_params
std::multimap< std::string, std::unique_ptr< InputParameters > >	_moose_object_params
std::string	_name
TreeNode *	_parent
SyntaxTree &	_syntax_tree

Detailed Description

This class represents a single node in our tree.

Definition at line 43 of file SyntaxTree.h.

Constructor & Destructor Documentation

TreeNode()

SyntaxTree::TreeNode::TreeNode	(	const std::string &	name,
		SyntaxTree &	syntax_tree,
		const std::string *	action = NULL,
		InputParameters *	params = NULL,
		TreeNode *	parent = NULL
	)

Definition at line 68 of file SyntaxTree.C.

  : _name(name), _parent(parent), _syntax_tree(syntax_tree)
{
  if (action)
    _action_params.emplace(*action, std::make_unique<InputParameters>(*params));
}

~TreeNode()

SyntaxTree::TreeNode::~TreeNode ( )

default

Member Function Documentation

getLongName()

std::string SyntaxTree::TreeNode::getLongName

(

const std::string &

delim = "/"

)

const

Definition at line 218 of file SyntaxTree.C.

{
  if (_parent)
    return _parent->getLongName(delim) + delim + _name;
  else
    return _name;
}

insertNode()

void SyntaxTree::TreeNode::insertNode	(	std::string &	syntax,
		const std::string &	action,
		bool	is_action_params = true,
		InputParameters *	params = NULL
	)

Definition at line 82 of file SyntaxTree.C.

{
  std::string::size_type pos = syntax.find_first_of("/");
  std::string item;
  bool is_leaf = true;
 
  item = syntax.substr(0, pos);
  if (pos != std::string::npos)
  {
    syntax = syntax.substr(pos + 1);
    is_leaf = false;
  }
 
  bool node_created = false;
  if (_children.find(item) == _children.end())
  {
    _children[item] = std::make_unique<TreeNode>(
        item, _syntax_tree, is_leaf && is_action_params ? &action : NULL, params, this);
    if (is_leaf && !is_action_params)
      _children[item]->insertParams(action, is_action_params, params);
    node_created = true;
  }
 
  if (!is_leaf)
    _children[item]->insertNode(syntax, action, is_action_params, params);
  else if (!node_created)
    _children[item]->insertParams(action, is_action_params, params);
}

insertParams()

void SyntaxTree::TreeNode::insertParams ( const std::string &  action, bool  is_action_params, InputParameters *  params = NULL  )

protected

Definition at line 115 of file SyntaxTree.C.

{
  if (is_action_params)
    _action_params.emplace(action, std::make_unique<InputParameters>(*params));
  else
    _moose_object_params.emplace(action, std::make_unique<InputParameters>(*params));
}

print()

std::string SyntaxTree::TreeNode::print	(	short	depth,
		const std::string &	search_string,
		bool &	found
	)

Definition at line 126 of file SyntaxTree.C.

{
  std::string doc = "";
  std::string long_name(getLongName());
  std::string name(_syntax_tree.isLongNames() ? long_name : _name);
  std::string out;
 
  if (depth < 0)
  {
    for (const auto & c_it : _children)
    {
      bool local_found = false;
      std::string local_out(c_it.second->print(depth + 1, search_string, local_found));
      found |= local_found; // Update the current frame's found variable
      if (local_found)
        out += local_out;
    }
    return out;
  }
 
  // GlobalParamsAction is special - we need to just always print it out
  // if (_name == "GlobalParamsAction")
  //   found = true;
 
  std::string indent((depth + 1) * 2, ' ');
 
  std::multimap<std::string, std::unique_ptr<InputParameters>>::const_iterator it =
      _moose_object_params.begin();
  do
  {
    bool local_found = false;
    std::string local_out;
 
    // Compare the block name, if it's matched we are going to pass an empty search string
    // which means match ALL parameters
    std::string local_search_string;
    if (MooseUtils::wildCardMatch(name, search_string))
      found = true;
    else
      local_search_string = search_string;
 
    if (it != _moose_object_params.end())
      doc = it->second->getClassDescription();
    local_out += _syntax_tree.printBlockOpen(name, depth, doc);
 
    for (const auto & a_it : _action_params)
      if (a_it.first != "EmptyAction")
      {
        local_out += _syntax_tree.printParams(
            name, long_name, *(a_it.second), depth, local_search_string, local_found);
        found |= local_found; // Update the current frame's found variable
        // DEBUG
        // Moose::out << "\n" << indent << "(" << ait->first << ")";
        // DEBUG
      }
 
    if (it != _moose_object_params.end())
    {
      local_out += _syntax_tree.printParams(
          name, long_name, *it->second, depth, local_search_string, local_found);
      found |= local_found;
      // DEBUG
      // Moose::out << "\n" << indent << "{" << it->first << "}";
      // DEBUG
    }
 
    local_out += _syntax_tree.preTraverse(depth);
 
    for (const auto & c_it : _children)
    {
      bool child_found = false;
      std::string child_out(c_it.second->print(depth + 1, local_search_string, child_found));
      found |= child_found; // Update the current frame's found variable
 
      if (child_found)
        local_out += child_out;
    }
 
    local_out += _syntax_tree.printBlockClose(name, depth);
 
    if (found)
      out += local_out;
 
    // If there are no moose object params then we have to be careful about how we
    // increment the iterator.  We only want to increment if we aren't already
    // at the end.
  } while (it != _moose_object_params.end() && ++it != _moose_object_params.end());
 
  return out;
}

Member Data Documentation

_action_params

std::multimap<std::string, std::unique_ptr<InputParameters> > SyntaxTree::TreeNode::_action_params

protected

Definition at line 67 of file SyntaxTree.h.

Referenced by TreeNode().

_children

std::map<std::string, std::unique_ptr<TreeNode> > SyntaxTree::TreeNode::_children

protected

Definition at line 66 of file SyntaxTree.h.

_moose_object_params

std::multimap<std::string, std::unique_ptr<InputParameters> > SyntaxTree::TreeNode::_moose_object_params

protected

Definition at line 68 of file SyntaxTree.h.

_name

std::string SyntaxTree::TreeNode::_name

protected

Definition at line 69 of file SyntaxTree.h.

_parent

TreeNode* SyntaxTree::TreeNode::_parent

protected

Definition at line 70 of file SyntaxTree.h.

_syntax_tree

SyntaxTree& SyntaxTree::TreeNode::_syntax_tree

protected

Definition at line 71 of file SyntaxTree.h.

---

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

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