Moose::Capability Class Reference

An entry for a single capability. More...

#include <Capability.h>

Public Types
using	Value = std::variant< bool, int, std::string >
	A capability can have a bool, int, or string value. More...

Public Member Functions
	Capability ()=delete
	Capability (const std::string_view name, const Capability::Value &value, const std::string_view doc)
const std::string &	getName () const
const std::string &	getDoc () const
const Capability::Value &	getValue () const
bool	getExplicit () const
const std::optional< std::set< std::string > > &	queryEnumeration () const
const std::set< std::string > &	getEnumeration () const
bool	hasEnumeration (const std::string &value) const
Capability &	setExplicit ()
	Set the capability to be explicit. More...
Capability &	setEnumeration (const std::set< std::string > &enumeration)
	Set the enumeration (allowed values) for the capability. More...
void	negateValue ()
	Negate a Capability value. More...
const bool *	queryBoolValue () const
const int *	queryIntValue () const
const std::string *	queryStringValue () const
bool	hasBoolValue () const
bool	hasIntValue () const
bool	hasStringValue () const
bool	getBoolValue () const
int	getIntValue () const
const std::string &	getStringValue () const
std::string	valueToString () const
std::string	toString () const
std::string	enumerationToString () const

Private Member Functions
	FRIEND_TEST (::CapabilityTest, negateValue)
	FRIEND_TEST (::CapabilitiesTest, isInstallationType)

Private Attributes
std::string	_name
	The name of capability. More...
std::string	_doc
	Description for the capability. More...
Capability::Value	_value
	The value the capability is set to. More...
bool	_explicit
	Whether or not this capability must be compared explicitly (not as a boolean check) More...
std::optional< std::set< std::string > >	_enumeration
	Possible enumeration for the capability, if any (string capabilities only) More...

Detailed Description

An entry for a single capability.

Definition at line 29 of file Capability.h.

Member Typedef Documentation

Value

using Moose::Capability::Value = std::variant<bool, int, std::string>

A capability can have a bool, int, or string value.

Definition at line 33 of file Capability.h.

Constructor & Destructor Documentation

Capability() [1/2]

Moose::Capability::Capability ( )

delete

Capability() [2/2]

Moose::Capability::Capability	(	const std::string_view	name,
		const Capability::Value &	value,
		const std::string_view	doc
	)

Definition at line 19 of file Capability.C.

  : _name(name), _doc(doc), _value(value), _explicit(false)
{
  // Check name validity
  if (getName().empty())
    throw CapabilityException("Capability has empty name");
  if (!std::regex_match(getName(), std::regex("[a-z0-9_-]+")))
    throw CapabilityException(
        "Capability '" + getName() +
        "': Name has unallowed characters; allowed characters = 'a-z, 0-9, _, -'");

  // String value validity
  if (const auto string_ptr = queryStringValue())
  {
    const std::regex string_regex("[a-z0-9_.-]+");
    if (!std::regex_match(*string_ptr, string_regex))
      throw CapabilityException(
          "String capability '" + getName() + "': value '" + *string_ptr +
          "' has unallowed characters; allowed characters = 'a-z, 0-9, _, ., -'");
  }
}

Member Function Documentation

enumerationToString()

std::string Moose::Capability::enumerationToString

(

)

const

Returns

The enumeration as a string of comma separated values.

This is only valid for a capability that has an enumeration.

Definition at line 150 of file Capability.C.

{
  if (_enumeration)
    return MooseUtils::stringJoin(
        std::vector<std::string>(_enumeration->begin(), _enumeration->end()), ", ");
  throw CapabilityException("Capability::enumerationToString(): Capability '",
                            getName(),
                            "' does not have an enumeration");
}

FRIEND_TEST() [1/2]

Moose::Capability::FRIEND_TEST ( ::CapabilityTest  , negateValue    )

private

FRIEND_TEST() [2/2]

Moose::Capability::FRIEND_TEST ( ::CapabilitiesTest  , isInstallationType    )

private

getBoolValue()

bool Moose::Capability::getBoolValue

(

)

const

Returns

The boolean capability value.

Will error if the value is not a boolean.

Definition at line 105 of file Capability.C.

{
  if (const auto bool_ptr = queryBoolValue())
    return *bool_ptr;
  throw CapabilityException("Capability::getBoolValue(): Capability " + toString() +
                            " is not a bool");
}

getDoc()

const std::string& Moose::Capability::getDoc ( ) const

inline

Returns

The documentation string.

Definition at line 48 of file Capability.h.

{ return _doc; }

getEnumeration()

const std::set< std::string > & Moose::Capability::getEnumeration

(

)

const

Returns

The enumeration.

Will error if the capability does not have an enumeration.

Only string-valued capabilites can have an enumeration.

Definition at line 50 of file Capability.C.

{
  if (!_enumeration)
    throw CapabilityException("Capability::getEnumeration(): Capability '" + getName() +
                              "' does not have an enumeration");
  return *_enumeration;
}

getExplicit()

bool Moose::Capability::getExplicit ( ) const

inline

Returns

Whether or not the capability is explicit.

Explicit implies that the capability cannot be compared as a boolean.

Definition at line 60 of file Capability.h.

{ return _explicit; }

getIntValue()

int Moose::Capability::getIntValue

(

)

const

Returns

The boolean capability value.

Will error if the value is not an integer.

Definition at line 114 of file Capability.C.

{
  if (const auto int_ptr = queryIntValue())
    return *int_ptr;
  throw CapabilityException("Capability::getIntValue(): Capability " + toString() +
                            " is not an integer");
}

getName()

const std::string& Moose::Capability::getName ( ) const

inline

Returns

The name of the capability.

Definition at line 43 of file Capability.h.

Referenced by Capability(), enumerationToString(), getEnumeration(), setEnumeration(), setExplicit(), and toString().

{ return _name; }

getStringValue()

const std::string & Moose::Capability::getStringValue

(

)

const

Returns

The string capability value.

Will error if the value is not a string.

Definition at line 123 of file Capability.C.

{
  if (const auto string_ptr = queryStringValue())
    return *string_ptr;
  throw CapabilityException("Capability::getStringValue(): Capability " + toString() +
                            " is not a string");
}

getValue()

const Capability::Value& Moose::Capability::getValue ( ) const

inline

Returns

The capability value.

Definition at line 53 of file Capability.h.

{ return _value; }

hasBoolValue()

bool Moose::Capability::hasBoolValue ( ) const

inline

Returns

Whether or not the capability value is a boolean.

Definition at line 130 of file Capability.h.

Referenced by setExplicit().

{ return std::holds_alternative<bool>(_value); }

hasEnumeration()

bool Moose::Capability::hasEnumeration

(

const std::string &

value

)

const

Returns

Whether or not the capability has the given enumeration value.

This is only valid for string-valued capabilities.

If the capability has no enumerations, this will always return true.

Definition at line 44 of file Capability.C.

Referenced by setEnumeration().

{
  return _enumeration ? _enumeration->count(value) : true;
}

hasIntValue()

bool Moose::Capability::hasIntValue ( ) const

inline

Returns

Whether or not the capability value is an integer.

Definition at line 135 of file Capability.h.

{ return std::holds_alternative<int>(_value); }

hasStringValue()

bool Moose::Capability::hasStringValue ( ) const

inline

Returns

Whether or not the capability value is a string.

Definition at line 140 of file Capability.h.

{ return std::holds_alternative<std::string>(_value); }

negateValue()

void Moose::Capability::negateValue ( )

inline

Negate a Capability value.

This should only be used by pycapabilities via the TestHarness when it needs to augment capabilities to check on if a check depeneds on a capability or not.

Definition at line 199 of file Capability.h.

{
  _explicit = false;
  _enumeration.reset();
  _value = false;
}

queryBoolValue()

const bool* Moose::Capability::queryBoolValue ( ) const

inline

Returns

The boolean capability value if it is a boolean.

Definition at line 117 of file Capability.h.

Referenced by getBoolValue(), and valueToString().

{ return std::get_if<bool>(&_value); }

queryEnumeration()

const std::optional<std::set<std::string> >& Moose::Capability::queryEnumeration ( ) const

inline

Returns

The enumeration, if set.

Only string-valued capabilites can have an enumeration.

Definition at line 67 of file Capability.h.

{ return _enumeration; }

queryIntValue()

const int* Moose::Capability::queryIntValue ( ) const

inline

Returns

The integer capability value if it is an integer.

Definition at line 121 of file Capability.h.

Referenced by getIntValue(), and valueToString().

{ return std::get_if<int>(&_value); }

queryStringValue()

const std::string* Moose::Capability::queryStringValue ( ) const

inline

Returns

The string capability value if it is a string.

Definition at line 125 of file Capability.h.

Referenced by Capability(), getStringValue(), setEnumeration(), and valueToString().

{ return std::get_if<std::string>(&_value); }

setEnumeration()

Capability & Moose::Capability::setEnumeration

(

const std::set< std::string > &

enumeration

)

Set the enumeration (allowed values) for the capability.

This is only valid for string-valued capabilities.

Definition at line 69 of file Capability.C.

{
  static const std::string error_prefix = "Capability::setEnumeration(): ";

  const auto string_ptr = queryStringValue();
  if (!string_ptr)
    throw CapabilityException(error_prefix + "Capability '" + getName() +
                              "' is not string-valued and cannot have an enumeration");

  if (_enumeration)
  {
    if (*_enumeration == enumeration)
      return *this;
    throw CapabilityException(error_prefix + "Capability '" + getName() +
                              "' already has an enumeration set");
  }

  if (enumeration.empty())
    throw CapabilityException(error_prefix + "Enumeration is empty for '" + getName() + "'");

  for (const auto & value : enumeration)
    if (!std::regex_match(value, std::regex("[a-z0-9_-]+")))
      throw CapabilityException(error_prefix + "Enumeration value '" + value +
                                "' for capability '" + getName() + "'" +
                                " has unallowed characters; allowed characters = 'a-z, 0-9, _, -'");

  _enumeration = enumeration;

  if (!hasEnumeration(*string_ptr))
    throw CapabilityException(error_prefix + "Capability " + toString() +
                              " value not within enumeration");

  return *this;
}

setExplicit()

Capability & Moose::Capability::setExplicit

(

)

Set the capability to be explicit.

Explicit implies that the capability cannot be compared as a boolean.

This is only valid for non-bool valued capabilities.

Definition at line 59 of file Capability.C.

{
  if (hasBoolValue())
    throw CapabilityException("Capability::setExplicit(): Capability '" + getName() +
                              "' is bool-valued and cannot be set as explicit");
  _explicit = true;
  return *this;
}

toString()

std::string Moose::Capability::toString

(

)

const

Returns

The capability as a string in the form of "name=value".

Definition at line 144 of file Capability.C.

Referenced by getBoolValue(), getIntValue(), getStringValue(), and setEnumeration().

{
  return getName() + "=" + valueToString();
}

valueToString()

std::string Moose::Capability::valueToString

(

)

const

Returns

The capability value as a string.

Definition at line 132 of file Capability.C.

Referenced by toString().

{
  if (const auto bool_ptr = queryBoolValue())
    return *bool_ptr ? "true" : "false";
  if (const auto string_ptr = queryStringValue())
    return *string_ptr;
  if (const auto int_ptr = queryIntValue())
    return std::to_string(*int_ptr);
  throw CapabilityException("Capability::valueToString(): Invalid type");
}

Member Data Documentation

_doc

std::string Moose::Capability::_doc

private

Description for the capability.

Definition at line 187 of file Capability.h.

Referenced by getDoc().

_enumeration

std::optional<std::set<std::string> > Moose::Capability::_enumeration

private

Possible enumeration for the capability, if any (string capabilities only)

Definition at line 194 of file Capability.h.

Referenced by enumerationToString(), getEnumeration(), hasEnumeration(), negateValue(), queryEnumeration(), and setEnumeration().

_explicit

bool Moose::Capability::_explicit

private

Whether or not this capability must be compared explicitly (not as a boolean check)

Definition at line 192 of file Capability.h.

Referenced by getExplicit(), negateValue(), and setExplicit().

_name

std::string Moose::Capability::_name

private

The name of capability.

Definition at line 185 of file Capability.h.

Referenced by getName().

_value

Capability::Value Moose::Capability::_value

private

The value the capability is set to.

Definition at line 189 of file Capability.h.

Referenced by getValue(), hasBoolValue(), hasIntValue(), hasStringValue(), negateValue(), queryBoolValue(), queryIntValue(), and queryStringValue().

---

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

• include/base/Capability.h
• src/base/Capability.C