Line data Source code
1 : //* This file is part of the MOOSE framework
2 : //* https://mooseframework.inl.gov
3 : //*
4 : //* All rights reserved, see COPYRIGHT for full restrictions
5 : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 : //*
7 : //* Licensed under LGPL 2.1, please see LICENSE for details
8 : //* https://www.gnu.org/licenses/lgpl-2.1.html
9 :
10 : #include "SyntaxTree.h"
11 :
12 : #include "InputParameters.h"
13 : #include "MooseUtils.h"
14 : #include "Parser.h"
15 :
16 : #include <algorithm>
17 : #include <cctype>
18 :
19 71076 : SyntaxTree::SyntaxTree(bool use_long_names)
20 71076 : : SyntaxFormatterInterface(), _use_long_names(use_long_names)
21 : {
22 71076 : }
23 :
24 71076 : SyntaxTree::~SyntaxTree() = default;
25 :
26 : void
27 2180901 : SyntaxTree::insertNode(std::string syntax,
28 : const std::string & action,
29 : bool is_action_params,
30 : InputParameters * params)
31 : {
32 2180901 : if (!_root)
33 35563 : _root = std::make_unique<TreeNode>("", *this);
34 :
35 2180901 : _root->insertNode(syntax, action, is_action_params, params);
36 2180901 : }
37 :
38 : std::string
39 35563 : SyntaxTree::print(const std::string & search_string)
40 : {
41 35563 : bool found = false;
42 35563 : std::string output;
43 :
44 : // Clear the list of "seen" parameters before printing the tree
45 35563 : _params_printed.clear();
46 :
47 35563 : if (_root)
48 35563 : output = _root->print(-1, search_string, found);
49 :
50 35563 : if (found)
51 35563 : return preamble() + output + postscript();
52 : else
53 0 : return "";
54 35563 : }
55 :
56 : void
57 18279685 : SyntaxTree::seenIt(const std::string & prefix, const std::string & item)
58 : {
59 18279685 : _params_printed.insert(prefix + item);
60 18279685 : }
61 :
62 : bool
63 60010259 : SyntaxTree::haveSeenIt(const std::string & prefix, const std::string & item) const
64 : {
65 60010259 : return _params_printed.find(prefix + item) != _params_printed.end();
66 : }
67 :
68 730189 : SyntaxTree::TreeNode::TreeNode(const std::string & name,
69 : SyntaxTree & syntax_tree,
70 : const std::string * action,
71 : InputParameters * params,
72 730189 : TreeNode * parent)
73 730189 : : _name(name), _parent(parent), _syntax_tree(syntax_tree)
74 : {
75 730189 : if (action)
76 475447 : _action_params.emplace(*action, std::make_unique<InputParameters>(*params));
77 730189 : }
78 :
79 730189 : SyntaxTree::TreeNode::~TreeNode() = default;
80 :
81 : void
82 3160514 : SyntaxTree::TreeNode::insertNode(std::string & syntax,
83 : const std::string & action,
84 : bool is_action_params,
85 : InputParameters * params)
86 : {
87 3160514 : std::string::size_type pos = syntax.find_first_of("/");
88 3160514 : std::string item;
89 3160514 : bool is_leaf = true;
90 :
91 3160514 : item = syntax.substr(0, pos);
92 3160514 : if (pos != std::string::npos)
93 : {
94 979613 : syntax = syntax.substr(pos + 1);
95 979613 : is_leaf = false;
96 : }
97 :
98 3160514 : bool node_created = false;
99 3160514 : if (_children.find(item) == _children.end())
100 : {
101 1389252 : _children[item] = std::make_unique<TreeNode>(
102 1389252 : item, _syntax_tree, is_leaf && is_action_params ? &action : NULL, params, this);
103 694626 : if (is_leaf && !is_action_params)
104 54018 : _children[item]->insertParams(action, is_action_params, params);
105 694626 : node_created = true;
106 : }
107 :
108 3160514 : if (!is_leaf)
109 979613 : _children[item]->insertNode(syntax, action, is_action_params, params);
110 2180901 : else if (!node_created)
111 1651436 : _children[item]->insertParams(action, is_action_params, params);
112 3160514 : }
113 :
114 : void
115 1705454 : SyntaxTree::TreeNode::insertParams(const std::string & action,
116 : bool is_action_params,
117 : InputParameters * params)
118 : {
119 1705454 : if (is_action_params)
120 1005551 : _action_params.emplace(action, std::make_unique<InputParameters>(*params));
121 : else
122 699903 : _moose_object_params.emplace(action, std::make_unique<InputParameters>(*params));
123 1705454 : }
124 :
125 : std::string
126 793463 : SyntaxTree::TreeNode::print(short depth, const std::string & search_string, bool & found)
127 : {
128 1586926 : std::string doc = "";
129 793463 : std::string long_name(getLongName());
130 793463 : std::string name(_syntax_tree.isLongNames() ? long_name : _name);
131 793463 : std::string out;
132 :
133 793463 : if (depth < 0)
134 : {
135 317701 : for (const auto & c_it : _children)
136 : {
137 282138 : bool local_found = false;
138 282138 : std::string local_out(c_it.second->print(depth + 1, search_string, local_found));
139 282138 : found |= local_found; // Update the current frame's found variable
140 282138 : if (local_found)
141 281384 : out += local_out;
142 282138 : }
143 35563 : return out;
144 : }
145 :
146 : // GlobalParamsAction is special - we need to just always print it out
147 : // if (_name == "GlobalParamsAction")
148 : // found = true;
149 :
150 757900 : std::string indent((depth + 1) * 2, ' ');
151 :
152 : std::multimap<std::string, std::unique_ptr<InputParameters>>::const_iterator it =
153 757900 : _moose_object_params.begin();
154 : do
155 : {
156 933514 : bool local_found = false;
157 933514 : std::string local_out;
158 :
159 : // Compare the block name, if it's matched we are going to pass an empty search string
160 : // which means match ALL parameters
161 933514 : std::string local_search_string;
162 933514 : if (MooseUtils::wildCardMatch(name, search_string))
163 905639 : found = true;
164 : else
165 27875 : local_search_string = search_string;
166 :
167 933514 : if (it != _moose_object_params.end())
168 763129 : doc = it->second->getClassDescription();
169 933514 : local_out += _syntax_tree.printBlockOpen(name, depth, doc);
170 :
171 4570072 : for (const auto & a_it : _action_params)
172 3636558 : if (a_it.first != "EmptyAction")
173 : {
174 7272996 : local_out += _syntax_tree.printParams(
175 7272996 : name, long_name, *(a_it.second), depth, local_search_string, local_found);
176 3636498 : found |= local_found; // Update the current frame's found variable
177 : // DEBUG
178 : // Moose::out << "\n" << indent << "(" << ait->first << ")";
179 : // DEBUG
180 : }
181 :
182 933514 : if (it != _moose_object_params.end())
183 : {
184 1526258 : local_out += _syntax_tree.printParams(
185 1526258 : name, long_name, *it->second, depth, local_search_string, local_found);
186 763129 : found |= local_found;
187 : // DEBUG
188 : // Moose::out << "\n" << indent << "{" << it->first << "}";
189 : // DEBUG
190 : }
191 :
192 933514 : local_out += _syntax_tree.preTraverse(depth);
193 :
194 1409276 : for (const auto & c_it : _children)
195 : {
196 475762 : bool child_found = false;
197 475762 : std::string child_out(c_it.second->print(depth + 1, local_search_string, child_found));
198 475762 : found |= child_found; // Update the current frame's found variable
199 :
200 475762 : if (child_found)
201 448641 : local_out += child_out;
202 475762 : }
203 :
204 933514 : local_out += _syntax_tree.printBlockClose(name, depth);
205 :
206 933514 : if (found)
207 905639 : out += local_out;
208 :
209 : // If there are no moose object params then we have to be careful about how we
210 : // increment the iterator. We only want to increment if we aren't already
211 : // at the end.
212 933514 : } while (it != _moose_object_params.end() && ++it != _moose_object_params.end());
213 :
214 757900 : return out;
215 793463 : }
216 :
217 : std::string
218 2055135 : SyntaxTree::TreeNode::getLongName(const std::string & delim) const
219 : {
220 2055135 : if (_parent)
221 2523344 : return _parent->getLongName(delim) + delim + _name;
222 : else
223 793463 : return _name;
224 : }
225 :
226 : bool
227 793463 : SyntaxTree::isLongNames() const
228 : {
229 793463 : return _use_long_names;
230 : }
|
