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 "YAMLFormatter.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "MooseEnum.h"
      14             : #include "MultiMooseEnum.h"
      15             : #include "Parser.h"
      16             : 
      17             : #include "libmesh/vector_value.h"
      18             : #include "libmesh/point.h"
      19             : 
      20             : // C++ includes
      21             : #include <sstream>
      22             : #include <vector>
      23             : 
      24          20 : YAMLFormatter::YAMLFormatter(bool dump_mode) : SyntaxTree(true), _dump_mode(dump_mode) {}
      25             : 
      26             : std::string
      27          20 : YAMLFormatter::preamble() const
      28             : {
      29             :   // important: start and end yaml data delimiters used by python
      30          40 :   return "**START YAML DATA**\n";
      31             : }
      32             : 
      33             : std::string
      34          20 : YAMLFormatter::postscript() const
      35             : {
      36          40 :   return "**END YAML DATA**\n";
      37             : }
      38             : 
      39             : std::string
      40       47434 : YAMLFormatter::printParams(const std::string & prefix,
      41             :                            const std::string & /*fully_qualified_name*/,
      42             :                            InputParameters & params,
      43             :                            short depth,
      44             :                            const std::string & search_string,
      45             :                            bool & found)
      46             : {
      47       47434 :   std::ostringstream oss;
      48       47434 :   std::string indent(depth * 2, ' ');
      49             : 
      50     1623030 :   for (auto & iter : params)
      51             :   {
      52     1575596 :     std::string name = iter.first;
      53             :     // First make sure we want to see this parameter, also block active and type
      54     2395992 :     if (params.isPrivate(iter.first) || name == "active" ||
      55     2395992 :         (search_string != "" && search_string != iter.first) || haveSeenIt(prefix, iter.first))
      56     1152330 :       continue;
      57             : 
      58      423266 :     found = true;
      59             : 
      60             :     // Mark it as "seen"
      61      423266 :     seenIt(prefix, iter.first);
      62             : 
      63             :     // Block params may be required and will have a doc string
      64      423266 :     std::string required = params.isParamRequired(iter.first) ? "Yes" : "No";
      65             : 
      66      423266 :     oss << indent << "  - name: " << name << "\n";
      67      423266 :     oss << indent << "    required: " << required << "\n";
      68      423266 :     oss << indent << "    default: !!str ";
      69             : 
      70             :     // Only output default if it has one
      71      423266 :     if (params.isParamValid(iter.first))
      72             :     {
      73             :       // prints the value, which is the default value when dumping the tree
      74             :       // because it hasn't been changed
      75             : 
      76             :       // Output stream, performing special operations for writing objects such as Points and
      77             :       // RealVectorValues
      78      286057 :       std::ostringstream toss;
      79      286057 :       buildOutputString(toss, iter);
      80             : 
      81             :       // remove additional '\n' possibly generated in output (breaks YAML parsing)
      82      286057 :       std::string tmp_str = toss.str();
      83     1318040 :       for (auto & ch : tmp_str)
      84     1031983 :         if (ch == '\n')
      85           0 :           ch = ' ';
      86      286057 :       if (tmp_str == ",")
      87          70 :         oss << "\"" << tmp_str << "\"";
      88             :       else
      89      285987 :         oss << tmp_str;
      90      286057 :     }
      91      137209 :     else if (params.hasDefaultCoupledValue(iter.first))
      92         340 :       oss << params.defaultCoupledValue(iter.first);
      93             : 
      94      423266 :     std::string doc = params.getDocString(iter.first);
      95      423266 :     MooseUtils::escape(doc);
      96             :     // Print the type
      97             :     oss << "\n"
      98      423266 :         << indent << "    cpp_type: " << params.type(iter.first) << "\n"
      99      423266 :         << indent << "    group_name: ";
     100      423266 :     std::string group_name = params.getGroupName(iter.first);
     101      423266 :     if (!group_name.empty())
     102      255419 :       oss << "'" << group_name << "'";
     103      423266 :     oss << "\n";
     104             : 
     105      423266 :     oss << indent << "    doc_unit: ";
     106      423266 :     std::string doc_unit = params.getDocUnit(iter.first);
     107      423266 :     if (!doc_unit.empty())
     108           0 :       oss << "'" << doc_unit << "'";
     109      423266 :     oss << "\n";
     110             : 
     111      423266 :     if (params.have_parameter<MooseEnum>(name))
     112       12705 :       addEnumOptionsAndDocs(oss, params.get<MooseEnum>(name), indent);
     113      423266 :     if (params.have_parameter<MultiMooseEnum>(name))
     114       12722 :       addEnumOptionsAndDocs(oss, params.get<MultiMooseEnum>(name), indent);
     115      423266 :     if (params.have_parameter<ExecFlagEnum>(name))
     116       11052 :       addEnumOptionsAndDocs(oss, params.get<ExecFlagEnum>(name), indent);
     117      423266 :     if (params.have_parameter<std::vector<MooseEnum>>(name))
     118          80 :       addEnumOptionsAndDocs(oss, params.get<std::vector<MooseEnum>>(name)[0], indent);
     119             : 
     120      423266 :     oss << indent << "    description: |\n      " << indent << doc << std::endl;
     121     1575596 :   }
     122             : 
     123       94868 :   return oss.str();
     124       47434 : }
     125             : 
     126             : template <typename T>
     127             : void
     128       36559 : YAMLFormatter::addEnumOptionsAndDocs(std::ostringstream & oss,
     129             :                                      T & param,
     130             :                                      const std::string & indent)
     131             : {
     132       36559 :   oss << indent << "    options: " << param.getRawNames() << '\n';
     133       36559 :   const auto & docs = param.getItemDocumentation();
     134       36559 :   if (!docs.empty())
     135             :   {
     136         130 :     oss << indent << "    option_docs:\n";
     137         490 :     for (const auto & doc : docs)
     138             :     {
     139         360 :       oss << indent << "    - name: " << doc.first.name() << "\n";
     140         360 :       oss << indent << "      description: |\n";
     141         360 :       oss << indent << "        " << doc.second << "\n";
     142             :     }
     143             :   }
     144       36559 : }
     145             : 
     146             : std::string
     147       48622 : YAMLFormatter::preTraverse(short depth) const
     148             : {
     149       48622 :   std::string indent(depth * 2, ' ');
     150             : 
     151       97244 :   return indent + "  subblocks:\n";
     152       48622 : }
     153             : 
     154             : std::string
     155       48622 : YAMLFormatter::printBlockOpen(const std::string & name, short depth, const std::string & doc)
     156             : {
     157       48622 :   std::ostringstream oss;
     158       48622 :   std::string indent(depth * 2, ' ');
     159             : 
     160       48622 :   std::string docEscaped = doc;
     161       48622 :   MooseUtils::escape(docEscaped);
     162             : 
     163       48622 :   oss << indent << "- name: " << name << "\n";
     164       48622 :   oss << indent << "  description: |\n" << indent << "    " << docEscaped << "\n";
     165       48622 :   oss << indent << "  parameters:\n";
     166             : 
     167       97244 :   return oss.str();
     168       48622 : }
     169             : 
     170             : std::string
     171       48622 : YAMLFormatter::printBlockClose(const std::string & /*name*/, short /*depth*/) const
     172             : {
     173       48622 :   return std::string();
     174             : }
     175             : 
     176             : void
     177      286057 : YAMLFormatter::buildOutputString(
     178             :     std::ostringstream & output,
     179             :     const std::iterator_traits<InputParameters::iterator>::value_type & p)
     180             : {
     181      286057 :   libMesh::Parameters::Value * val = MooseUtils::get(p.second);
     182             : 
     183             :   // Account for Point
     184      286057 :   InputParameters::Parameter<Point> * ptr0 = dynamic_cast<InputParameters::Parameter<Point> *>(val);
     185             : 
     186             :   // Account for RealVectorValues
     187             :   InputParameters::Parameter<RealVectorValue> * ptr1 =
     188      286057 :       dynamic_cast<InputParameters::Parameter<RealVectorValue> *>(val);
     189             : 
     190             :   // Output the Point components
     191      286057 :   if (ptr0)
     192         270 :     output << ptr0->get().operator()(0) << " " << ptr0->get().operator()(1) << " "
     193         270 :            << ptr0->get().operator()(2);
     194             : 
     195             :   // Output the RealVectorValue components
     196      285787 :   else if (ptr1)
     197         120 :     output << ptr1->get().operator()(0) << " " << ptr1->get().operator()(1) << " "
     198         120 :            << ptr1->get().operator()(2);
     199             : 
     200             :   // General case, call the print operator
     201             :   else
     202      285667 :     p.second->print(output);
     203      286057 : }