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             : // MOOSE includes
      11             : #include "MooseObjectParameterName.h"
      12             : #include "MooseError.h"
      13             : 
      14             : // STL includes
      15             : #include <iostream>
      16             : 
      17     1381513 : MooseObjectParameterName::MooseObjectParameterName(const MooseObjectName & obj_name,
      18     1381513 :                                                    const std::string & param)
      19     1381513 :   : MooseObjectName(obj_name), _parameter(param)
      20             : {
      21     1381513 :   _combined = _tag + _name + _parameter;
      22     1381513 : }
      23             : 
      24         109 : MooseObjectParameterName::MooseObjectParameterName(const std::string & tag,
      25             :                                                    const std::string & name,
      26             :                                                    const std::string & param,
      27         109 :                                                    const std::string & separator)
      28         109 :   : MooseObjectName(tag, name, separator), _parameter(param)
      29             : {
      30         109 :   _combined += _parameter;
      31         109 : }
      32             : 
      33     1426863 : MooseObjectParameterName::MooseObjectParameterName(const MooseObjectParameterName & rhs)
      34     1426863 :   : MooseObjectName(rhs._tag, rhs._name, rhs._separator), _parameter(rhs._parameter)
      35             : {
      36     1426863 :   _combined = _tag + _name + _parameter;
      37     1426863 : }
      38             : 
      39        3193 : MooseObjectParameterName::MooseObjectParameterName(std::string name) : MooseObjectName()
      40             : {
      41             :   // The tag precedes the :: (this is used in _moose_base::name and control_tag::name conventions)
      42        3193 :   std::size_t idx = name.find("::");
      43        3193 :   if (idx != std::string::npos)
      44             :   {
      45          47 :     _tag = name.substr(0, idx);
      46          47 :     name.erase(0, idx + 2);
      47          47 :     _separator = "::";
      48             :   }
      49             : 
      50             :   // Locate the param name
      51        3193 :   idx = name.rfind("/");
      52        3193 :   if (idx != std::string::npos)
      53             :   {
      54        3188 :     _parameter = name.substr(idx + 1);
      55        3188 :     name.erase(idx);
      56             :   }
      57             :   else // if a slash isn't located then the entire name must be the parameter
      58             :   {
      59           5 :     _parameter = name;
      60           5 :     name.erase();
      61             :   }
      62             : 
      63             :   // If there is a second slash, there is a syntax based tag: tag/object_name/param
      64        3193 :   idx = name.rfind("/");
      65        3193 :   if (idx != std::string::npos)
      66             :   {
      67        3141 :     _name = name.substr(idx + 1);
      68        3141 :     name.erase(idx);
      69        3141 :     _tag = name;
      70             :   }
      71             : 
      72             :   // If content still exists in "name", then this must be the object name
      73        3193 :   if (_name.empty() && !name.empty())
      74          47 :     _name = name;
      75             : 
      76             :   // Set the combined name for sorting
      77        3193 :   _combined = _tag + _name + _parameter;
      78        3193 : }
      79             : 
      80             : bool
      81     1657916 : MooseObjectParameterName::operator==(const MooseObjectParameterName & rhs) const
      82             : {
      83     1895682 :   if (MooseObjectName::operator==(rhs) &&
      84      237766 :       (_parameter == rhs._parameter || _parameter == "*" || rhs._parameter == "*"))
      85      102830 :     return true;
      86     1555086 :   return false;
      87             : }
      88             : 
      89             : bool
      90           0 : MooseObjectParameterName::operator==(const MooseObjectName & rhs) const
      91             : {
      92           0 :   return MooseObjectName::operator==(rhs);
      93             : }
      94             : 
      95             : bool
      96          12 : MooseObjectParameterName::operator!=(const MooseObjectParameterName & rhs) const
      97             : {
      98          12 :   return !(*this == rhs);
      99             : }
     100             : 
     101             : bool
     102           0 : MooseObjectParameterName::operator!=(const MooseObjectName & rhs) const
     103             : {
     104           0 :   return MooseObjectName::operator!=(rhs);
     105             : }
     106             : 
     107             : bool
     108          59 : MooseObjectParameterName::operator<(const MooseObjectParameterName & rhs) const
     109             : {
     110          59 :   return (_combined < rhs._combined);
     111             : }
     112             : 
     113             : std::ostream &
     114         319 : operator<<(std::ostream & stream, const MooseObjectParameterName & obj)
     115             : {
     116         319 :   if (obj._tag.empty() && obj._name.empty())
     117           4 :     return stream << obj._parameter;
     118         315 :   else if (obj._tag.empty())
     119           0 :     return stream << obj._name << "/" << obj._parameter;
     120         315 :   else if (obj._name.empty())
     121           0 :     return stream << obj._tag << obj._separator << obj._parameter;
     122             :   else
     123         315 :     return stream << obj._tag << obj._separator << obj._name << "/" << obj._parameter;
     124             : }
     125             : 
     126             : void
     127           0 : MooseObjectParameterName::check()
     128             : {
     129           0 :   MooseObjectName::check();
     130           0 :   if (_parameter.empty())
     131           0 :     mooseError("The supplied parameter name cannot be empty, to allow for any parameter name to be "
     132             :                "supplied use the '*' character.");
     133           0 : }