MooseObjectName Class Reference

A class for storing the names of MooseObject by tag and object name. More...

#include <MooseObjectName.h>

Inheritance diagram for MooseObjectName:

Public Member Functions
	MooseObjectName (const std::string &tag, const std::string &name, const std::string &separator=std::string("/"))
	Construct the name object. More...
virtual	~MooseObjectName ()=default
	This class requires a virtual (but default) desctructor since it has virtual functions. More...
	MooseObjectName (std::string name)
	Build an object given a raw parameter name (e.g., from an input file parameter) More...
	MooseObjectName (const MooseObjectName &rhs)
	Copy constructor. More...
const std::string &	name () const
	Return the name. More...
const std::string &	tag () const
	Return the tag. More...
bool	operator== (const MooseObjectName &rhs) const
	Comparison operators. More...
bool	operator!= (const MooseObjectName &rhs) const
bool	operator< (const MooseObjectName &rhs) const

Protected Member Functions
	MooseObjectName ()
	A constructor for use by MooseObjectParameterName. More...
virtual void	check ()
	Check that the name and tag are supplied correctly. More...

Protected Attributes
std::string	_tag
std::string	_name
std::string	_combined
std::string	_separator

Friends
std::ostream &	operator<< (std::ostream &stream, const MooseObjectName &obj)
	Allows this to be used with std:: cout. More...

Detailed Description

A class for storing the names of MooseObject by tag and object name.

This class is used by the Control logic system, allowing for multiple tags to be applied to many different MooseObjects.

There are multiple ways to create an MooseObjectName object, the best being to input the tag and object name as separate inputs. However, this is not always practically if the supplied name is coming from an input file. Therefore, you can use the following single string methods.

MooseObjectName(foo::bar) -> tag="foo", name="bar" MooseObjectName(foo/bar) -> tag="foo", name="bar" MooseObjectName(foo/foo/bar) -> tag="foo/foo", name="bar"

This class also allows for glob style '*' to be used to allow for fuzzy comparisons to be performed.

MooseObjectName name1("*", "bar"); MooseObjectName name2("foo", "bar"); name1 == name2 (True)

MooseObjectName name3("foo", "*"); MooseObjectName name4("foo", "bar"); name3 == name4 (True)

Definition at line 40 of file MooseObjectName.h.

Constructor & Destructor Documentation

MooseObjectName() [1/4]

MooseObjectName::MooseObjectName	(	const std::string &	tag,
		const std::string &	name,
		const std::string &	separator = std::string("/")
	)

Construct the name object.

Parameters

tag	The tag to apply the object
name	The name of the object

Definition at line 17 of file MooseObjectName.C.

  : _tag(tag), _name(name), _combined(tag + name), _separator(separator)
{
  check();
}

~MooseObjectName()

virtual MooseObjectName::~MooseObjectName ( )

virtualdefault

This class requires a virtual (but default) desctructor since it has virtual functions.

MooseObjectName() [2/4]

MooseObjectName::MooseObjectName

(

std::string

name

)

Build an object given a raw parameter name (e.g., from an input file parameter)

Definition at line 25 of file MooseObjectName.C.

                                               : _separator("::")
{
  // Tags may be separated by a :: or the last /
  std::size_t idx0 = name.find("::");
  std::size_t idx1 = name.rfind("/");

  // Case when :: is found
  if (idx0 != std::string::npos)
  {
    _tag = name.substr(0, idx0);
    _name = name.erase(0, idx0 + 2);
  }

  // Case when a / is found
  else if (idx1 != std::string::npos)
  {
    _tag = name.substr(0, idx1);
    _name = name.erase(0, idx1 + 1);
    _separator = "/";
  }

  // If you get here, just use the supplied name without a tag (this will produce an error in check)
  else
    _name = name;

  check();
  _combined = _tag + _name;
}

MooseObjectName() [3/4]

MooseObjectName::MooseObjectName

(

const MooseObjectName &

rhs

)

Copy constructor.

Definition at line 56 of file MooseObjectName.C.

  : _tag(rhs._tag), _name(rhs._name), _combined(rhs._combined), _separator(rhs._separator)
{
}

MooseObjectName() [4/4]

MooseObjectName::MooseObjectName ( )

protected

A constructor for use by MooseObjectParameterName.

Definition at line 54 of file MooseObjectName.C.

: _separator("/") {}

Member Function Documentation

check()

void MooseObjectName::check ( )

protectedvirtual

Check that the name and tag are supplied correctly.

Reimplemented in MooseObjectParameterName.

Definition at line 94 of file MooseObjectName.C.

Referenced by MooseObjectParameterName::check(), and MooseObjectName().

{
  if (_name.empty())
    mooseError("The supplied name cannot be empty, to allow for any name to be supplied use the "
               "'*' character.");
  if (_tag.empty())
    mooseError("The supplied tag cannot be empty, to allow for any tag to be supplied use the '*' "
               "character.");
}

name()

const std::string& MooseObjectName::name ( ) const

inline

Return the name.

Definition at line 71 of file MooseObjectName.h.

Referenced by InputParameterWarehouse::addControllableObjectAlias(), MooseObjectName(), and MooseObjectParameterName::MooseObjectParameterName().

{ return _name; }

operator!=()

bool MooseObjectName::operator!=

(

const MooseObjectName &

rhs

)

const

Definition at line 73 of file MooseObjectName.C.

Referenced by MooseObjectParameterName::operator!=().

{
  return !(*this == rhs);
}

operator<()

bool MooseObjectName::operator<

(

const MooseObjectName &

rhs

)

const

Definition at line 79 of file MooseObjectName.C.

{
  return (_combined < rhs._combined);
}

operator==()

bool MooseObjectName::operator==

(

const MooseObjectName &

rhs

)

const

Comparison operators.

The less than operator is required so this container can work in std::map.

See also

InputParameterWarehouse

Definition at line 62 of file MooseObjectName.C.

Referenced by MooseObjectParameterName::operator==().

{
  if ((_name == rhs._name || _name == "*" || rhs._name == "*") &&
      (_tag == rhs._tag || _tag == "*" || rhs._tag == "*"))
  {
    return true;
  }
  return false;
}

tag()

const std::string& MooseObjectName::tag ( ) const

inline

Return the tag.

Definition at line 76 of file MooseObjectName.h.

{ return _tag; }

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  stream, const MooseObjectName &  obj  )

friend

Allows this to be used with std:: cout.

Definition at line 85 of file MooseObjectName.C.

{
  if (obj._tag.empty())
    return stream << obj._name;
  else
    return stream << obj._tag << obj._separator << obj._name;
}

Member Data Documentation

_combined

std::string MooseObjectName::_combined

protected

Definition at line 104 of file MooseObjectName.h.

Referenced by MooseObjectName(), MooseObjectParameterName::MooseObjectParameterName(), MooseObjectParameterName::operator<(), and operator<().

_name

std::string MooseObjectName::_name

protected

Definition at line 103 of file MooseObjectName.h.

Referenced by check(), MooseObjectName(), MooseObjectParameterName::MooseObjectParameterName(), name(), operator<<(), and operator==().

_separator

std::string MooseObjectName::_separator

protected

Definition at line 105 of file MooseObjectName.h.

Referenced by MooseObjectName(), MooseObjectParameterName::MooseObjectParameterName(), and operator<<().

_tag

std::string MooseObjectName::_tag

protected

Storage for the various name components

Definition at line 102 of file MooseObjectName.h.

Referenced by check(), MooseObjectName(), MooseObjectParameterName::MooseObjectParameterName(), operator<<(), operator==(), and tag().

---

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

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