ControllableParameter Class Reference

The ControllableParameter class is simply a set of ControllableItem objects. More...

#include <ControllableParameter.h>

Public Member Functions
	ControllableParameter ()=default
virtual	~ControllableParameter ()=default
	ControllableParameter (ControllableParameter &&)=default
	ControllableParameter (const ControllableParameter &)=delete
ControllableParameter &	operator= (const ControllableParameter &)=delete
ControllableParameter &	operator= (ControllableParameter &&)=delete
bool	empty ()
	Return true if the container is empty.
std::string	dump () const
	Return a string that lists the parameters stored by this object.
template<typename T >
void	set (const T &value, bool type_check=true)
	Set the value(s) of the controlled parameters stored in this class.
template<typename T >
std::vector< T >	get (bool type_check=true, bool warn_when_values_difffer=false) const
	Return a copy of the values of the given type.
template<typename T >
bool	check ()
	Check size() and the type of the stored items, i.e., there must be items with the given type.
void	checkExecuteOnType (const ExecFlagType &current) const
	Check the execute flags.
void	add (ControllableItem *item)
	Adds the supplied item with the other items within this object.

Private Attributes
std::vector< ControllableItem * >	_items
	Storage for the ControllableItems, these are stored as pointers to avoid copies.

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

Detailed Description

The ControllableParameter class is simply a set of ControllableItem objects.

This object is what is used from within a Control for setting input parameter values. These objects are made on demand by the Control objects.

This class is needed to allow for multiple parameters to be set with a single interface.

Definition at line 26 of file ControllableParameter.h.

Constructor & Destructor Documentation

ControllableParameter() [1/3]

ControllableParameter::ControllableParameter ( )

default

~ControllableParameter()

virtual ControllableParameter::~ControllableParameter ( )

virtualdefault

ControllableParameter() [2/3]

ControllableParameter::ControllableParameter ( ControllableParameter &&  )

default

ControllableParameter() [3/3]

ControllableParameter::ControllableParameter ( const ControllableParameter &  )

delete

Member Function Documentation

add()

void ControllableParameter::add

(

ControllableItem *

item

)

Adds the supplied item with the other items within this object.

Definition at line 14 of file ControllableParameter.C.

{
  _items.push_back(item);
}

Referenced by InputParameterWarehouse::getControllableParameter().

check()

template<typename T >

bool ControllableParameter::check

(

)

Check size() and the type of the stored items, i.e., there must be items with the given type.

Definition at line 129 of file ControllableParameter.h.

{
  bool type = std::all_of(
      _items.begin(), _items.end(), [](ControllableItem * item) { return item->check<T>(); });
  return type && !empty();
}

checkExecuteOnType()

void ControllableParameter::checkExecuteOnType

(

const ExecFlagType &

current

)

const

Check the execute flags.

Definition at line 29 of file ControllableParameter.C.

{
  for (const ControllableItem * const item : _items)
  {
    const std::set<ExecFlagType> & flags = item->getExecuteOnFlags();
    if (!flags.empty() && flags.find(current) == flags.end())
      mooseError("The controllable parameter (",
                 item->name(),
                 ") is not allowed to execute on '",
                 current,
                 "', it is only allowed to execute on '",
                 MooseUtils::join(flags, " "),
                 "'.");
  }
}

dump()

std::string ControllableParameter::dump

(

)

const

Return a string that lists the parameters stored by this object.

This is used by ControlInterface::getControlParamByName for error reporting.

Definition at line 20 of file ControllableParameter.C.

{
  std::ostringstream oss;
  for (auto item_ptr : _items)
    oss << item_ptr->dump();
  return oss.str();
}

Referenced by InputParameterWarehouse::dumpChangedControls(), and get().

empty()

bool ControllableParameter::empty ( )

inline

Return true if the container is empty.

Definition at line 40 of file ControllableParameter.h.

{ return _items.size() == 0; }

Referenced by check(), and Control::hasControllableParameterByName().

get()

template<typename T >

std::vector< T > ControllableParameter::get	(	bool	type_check = true,
		bool	warn_when_values_difffer = false
	)		const

Return a copy of the values of the given type.

Definition at line 96 of file ControllableParameter.h.

{
  std::vector<T> output;
  for (const ControllableItem * const item : _items)
  {
    std::vector<T> local = item->get<T>(type_check);
    output.insert(output.end(), local.begin(), local.end());
  }
 
  // Produce a warning, if the flag is true, when multiple parameters have different values
  if (warn_when_values_differ && _items.size() > 1)
  {
    // The first parameter to test against
    const T value0 = output[0];
 
    // Loop over all other parameter values
    for (T value : output)
    {
      if (value0 != value)
      {
        std::ostringstream oss;
        oss << "The following controlled parameters are being retrieved, but the values differ:\n";
        oss << dump();
        mooseWarning(oss.str());
      }
    }
  }
 
  return output;
}

Referenced by InputParameterWarehouse::getControllableParameterValues(), Control::getControllableValueByName(), Control::getControllableValueByName(), Control::getControllableValueByName(), Control::getControllableValueByName(), and Control::getControllableValueByName().

operator=() [1/2]

ControllableParameter & ControllableParameter::operator= ( const ControllableParameter &  )

delete

operator=() [2/2]

ControllableParameter & ControllableParameter::operator= ( ControllableParameter &&  )

delete

set()

template<typename T >

void ControllableParameter::set	(	const T &	value,
		bool	type_check = true
	)

Set the value(s) of the controlled parameters stored in this class.

Parameters

value

The value to change the parameters to.

Definition at line 88 of file ControllableParameter.h.

{
  for (ControllableItem * item : _items)
    item->set<T>(value, type_check);
}

Referenced by Control::setControllableValueByName(), Control::setControllableValueByName(), Control::setControllableValueByName(), Control::setControllableValueByName(), and Control::setControllableValueByName().

Friends And Related Symbol Documentation

operator<<

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

friend

Allows this to be used with std:: cout.

Definition at line 45 of file ControllableParameter.C.

{
  return stream << obj.dump();
}

Member Data Documentation

_items

std::vector<ControllableItem *> ControllableParameter::_items

private

Storage for the ControllableItems, these are stored as pointers to avoid copies.

Definition at line 83 of file ControllableParameter.h.

Referenced by add(), check(), checkExecuteOnType(), dump(), empty(), get(), and set().

---

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

• include/controls/ControllableParameter.h
• src/controls/ControllableParameter.C