Moose::ParameterRegistration Namespace Reference

Namespaces
	detail

Functions
template<class T >
void	setScalarValue (T &value, const hit::Field &field)
	Converts the given field node into a scalar of the given type. More...
template<class T >
void	setVectorValue (std::vector< T > &value, const hit::Field &field)
	Converts the given field node into a vector of the given type. More...
template<class T >
void	setDoubleVectorValue (std::vector< std::vector< T >> &value, const hit::Field &field)
	Converts the given field node into a vector-of-vectors of the given type. More...
template<class T >
void	setTripleVectorValue (std::vector< std::vector< std::vector< T >>> &value, const hit::Field &field)
	Converts the given field node into a triple-indexed vector of the given type. More...
template<class Key , class Value >
void	setMapValue (std::map< Key, Value > &value, const hit::Field &field)
	Converts the given field node into a map with the given types. More...
template<>
void	setScalarValue (bool &value, const hit::Field &field)
	setScalarValue specialiation for bool More...

Function Documentation

setDoubleVectorValue()

template<class T >

void Moose::ParameterRegistration::setDoubleVectorValue	(	std::vector< std::vector< T >> &	value,
		const hit::Field &	field
	)

Converts the given field node into a vector-of-vectors of the given type.

Definition at line 163 of file ParameterRegistration.h.

{
  value.clear();
  const auto strval = MooseUtils::trim(field.param<std::string>());
  if (strval.empty())
    return;

  // split vector on ";" (the substrings are _not_ of type T yet)
  // The zero length here is intentional, as we want something like:
  // "abc; 123;" -> ["abc", "123", ""]
  const auto tokens = MooseUtils::split(strval, ";");

  value.resize(tokens.size());
  for (const auto i : index_range(tokens))
  {
    const auto token = MooseUtils::trim(tokens[i]);
    if (!MooseUtils::tokenizeAndConvert<T>(token, value[i]))
      throw std::invalid_argument("invalid syntax for " + MooseUtils::prettyCppType<T>() +
                                  " double vector parameter: " + field.fullpath() + "[" +
                                  std::to_string(i) + "]='" + token + "'");
  }
}

setMapValue()

template<class Key , class Value >

void Moose::ParameterRegistration::setMapValue	(	std::map< Key, Value > &	value,
		const hit::Field &	field
	)

Converts the given field node into a map with the given types.

Definition at line 247 of file ParameterRegistration.h.

{
  value.clear();

  const auto string_vec = field.param<std::vector<std::string>>();
  auto it = string_vec.begin();
  while (it != string_vec.end())
  {
    const auto & string_key = *(it++);
    if (it == string_vec.end())
      throw std::invalid_argument(
          "odd number of entries for map parameter '" + field.fullpath() +
          "'; there must be an even number or else you will end up with a key without a value");
    const auto & string_value = *(it++);

    std::pair<Key, Value> pr;

    // convert key
    if (!MooseUtils::convert<Key>(string_key, pr.first, false))
      throw std::invalid_argument("invalid " + MooseUtils::prettyCppType<Key>() +
                                  " syntax for map parameter '" + field.fullpath() + "' key: '" +
                                  string_key + "'");

    // convert value
    if (!MooseUtils::convert<Value>(string_value, pr.second, false))
      throw std::invalid_argument("invalid " + MooseUtils::prettyCppType<Value>() +
                                  " syntax for map parameter '" + field.fullpath() + "' value: '" +
                                  string_value + "'");
    // attempt insert
    if (!value.insert(std::move(pr)).second)
      throw std::invalid_argument("duplicate entry for map parameter: '" + field.fullpath() +
                                  "'; key '" + string_key + "' appears multiple times");
  }
}

setScalarValue() [1/2]

template<class T >

void Moose::ParameterRegistration::setScalarValue	(	T &	value,
		const hit::Field &	field
	)

Converts the given field node into a scalar of the given type.

Definition at line 100 of file ParameterRegistration.h.

{
  const auto strval = field.param<std::string>();
  if constexpr (std::is_base_of_v<std::string, T>)
  {
    value = strval;
  }
  else
  {
    if (!MooseUtils::convert<T>(strval, value, false))
      throw std::invalid_argument("invalid syntax for " + MooseUtils::prettyCppType<T>() +
                                  " parameter: " + field.fullpath() + "='" + strval + "'");
  }
}

setScalarValue() [2/2]

template<>

void Moose::ParameterRegistration::setScalarValue	(	bool &	value,
		const hit::Field &	field
	)

setScalarValue specialiation for bool

Definition at line 24 of file ParameterRegistration.C.

{
  // Handles non-quoted values
  try
  {
    value = field.boolVal();
  }
  // Handles quoted values
  catch (hit::Error &)
  {
    const auto strval = field.param<std::string>();
    if (strval == "1")
      value = true;
    else if (strval == "0")
      value = false;
    else if (!hit::toBool(strval, &value))
      throw std::invalid_argument("invalid boolean syntax for parameter: " + field.path() + "='" +
                                  strval + "'");
  }
}

setTripleVectorValue()

template<class T >

void Moose::ParameterRegistration::setTripleVectorValue	(	std::vector< std::vector< std::vector< T >>> &	value,
		const hit::Field &	field
	)

Converts the given field node into a triple-indexed vector of the given type.

Definition at line 188 of file ParameterRegistration.h.

{
  value.clear();
  const auto value_string = field.param<std::string>();
  if (value_string.find_first_not_of(' ', 0) == std::string::npos)
    return;

  // Add a space between neighboring delim's, before the first delim if nothing is ahead of it, and
  // after the last delim if nothing is behind it.
  std::string buffer;
  buffer.push_back(value_string[0]);
  if (buffer[0] == '|' || buffer[0] == ';')
    buffer = ' ' + buffer;
  for (std::string::size_type i = 1; i < value_string.size(); i++)
  {
    const auto val = value_string[i];
    const auto last_val = value_string[i - 1];
    if ((last_val == '|' || last_val == ';') && (val == '|' || val == ';'))
      buffer.push_back(' ');
    buffer.push_back(val);
  }
  if (buffer.back() == '|' || buffer.back() == ';')
    buffer.push_back(' ');

  // split vector at delim | to get a series of 2D subvectors
  std::vector<std::string> outer_tokens;
  MooseUtils::tokenize(buffer, outer_tokens, 1, "|");
  value.resize(outer_tokens.size());
  for (const auto i : index_range(outer_tokens))
  {
    const auto & inner_token = outer_tokens[i];
    auto & inner_value = value[i];

    // Identify empty subvector first
    if (inner_token.find_first_not_of(' ', 0) == std::string::npos)
    {
      mooseAssert(inner_value.empty(), "Should be empty");
      continue;
    }

    // split each 2D subvector at delim ; to get 1D sub-subvectors
    // NOTE: the 1D sub-subvectors are _not_ of type T yet
    std::vector<std::string> inner_tokenized;
    MooseUtils::tokenize(inner_token, inner_tokenized, 1, ";");
    inner_value.resize(inner_tokenized.size());
    for (const auto j : index_range(inner_tokenized))
    {
      const auto token = MooseUtils::trim(inner_tokenized[j]);
      if (!MooseUtils::tokenizeAndConvert<T>(token, inner_value[j]))
        throw std::invalid_argument("invalid syntax for " + MooseUtils::prettyCppType<T>() +
                                    " triple vector parameter: " + field.fullpath() + "[" +
                                    std::to_string(i) + "][" + std::to_string(j) + "]='" + token +
                                    "'");
    }
  }
}

setVectorValue()

template<class T >

void Moose::ParameterRegistration::setVectorValue	(	std::vector< T > &	value,
		const hit::Field &	field
	)

Converts the given field node into a vector of the given type.

Definition at line 117 of file ParameterRegistration.h.

{
  value.clear();
  const auto base_values = field.param<std::vector<std::string>>();
  if constexpr (std::is_base_of_v<std::string, T>)
  {
    std::copy(base_values.begin(), base_values.end(), std::back_inserter(value));
  }
  else
  {
    value.resize(base_values.size());
    for (const auto i : index_range(base_values))
    {
      if constexpr (std::is_same_v<bool, T>)
      {
        if (base_values[i] == "1")
        {
          value[i] = true;
          continue;
        }
        else if (base_values[i] == "0")
        {
          value[i] = false;
          continue;
        }
        else if (bool bool_val; hit::toBool(base_values[i], &bool_val))
        {
          value[i] = bool_val;
          continue;
        }
      }
      else
      {
        if (MooseUtils::convert<T>(base_values[i], value[i], false))
          continue;
      }

      throw std::invalid_argument("invalid syntax for " + MooseUtils::prettyCppType<T>() +
                                  " vector parameter: " + field.fullpath() + "[" +
                                  std::to_string(i) + "]='" + base_values[i] + "'");
    }
  }
}