ControllableItem.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "libmesh/parameters.h"
#include "MooseObjectParameterName.h"
#include "MooseError.h"
#include "ControlOutput.h"
 
class ControllableItem
{
public:
  ControllableItem(const MooseObjectParameterName & name,
                   libMesh::Parameters::Value * value,
                   const std::set<ExecFlagType> & flags = {});
  virtual ~ControllableItem() = default;
 
  ControllableItem(const ControllableItem &) = default;
  ControllableItem(ControllableItem &&) = default;
 
  ControllableItem & operator=(const ControllableItem &) = delete;
  ControllableItem & operator=(ControllableItem &&) = delete;
 
  void connect(ControllableItem * item, bool type_check = true);
 
  template <typename T>
  void set(const T & value, bool type_check = true);
 
  template <typename T>
  std::vector<T> get(bool type_check = true) const;
 
  template <typename T>
  bool check() const;
 
 
  bool operator==(const ControllableItem & rhs) const { return name() == rhs.name(); }
  bool operator!=(const ControllableItem & rhs) const { return name() != rhs.name(); }
  bool operator<(const ControllableItem & rhs) const { return name() < rhs.name(); }
 
  virtual const MooseObjectParameterName & name() const;
 
  std::string type() const;
 
  virtual std::string dump(unsigned int indent = 0) const;
 
 
  void resetChanged() { _changed = false; }
  bool isChanged() { return _changed; }
 
  const std::set<ExecFlagType> & getExecuteOnFlags() const { return _execute_flags; }
 
  friend std::ostream & operator<<(std::ostream & stream, const ControllableItem & obj);
 
protected:
  ControllableItem();
 
  std::vector<std::pair<MooseObjectParameterName, libMesh::Parameters::Value *>> _pairs;
 
  bool _changed = false;
 
  std::set<ExecFlagType> _execute_flags;
};
 
template <typename T>
void
ControllableItem::set(const T & value, bool type_check /*=true*/)
{
  for (auto & pair : _pairs)
  {
    libMesh::Parameters::Parameter<T> * param =
        dynamic_cast<libMesh::Parameters::Parameter<T> *>(pair.second);
    if (type_check && param == nullptr)
      mooseError("Failed to set the '",
                 pair.first,
                 "' parameter the supplied template argument must be of type '",
                 pair.second->type(),
                 "'.");
    else if (param != nullptr)
    {
      param->set() = value;
      _changed = true;
    }
  }
}
 
template <typename T>
std::vector<T>
ControllableItem::get(bool type_check /*=true*/) const
{
  std::vector<T> output;
  output.reserve(_pairs.size());
  for (const auto & pair : _pairs)
  {
    libMesh::Parameters::Parameter<T> * param =
        dynamic_cast<libMesh::Parameters::Parameter<T> *>(pair.second);
    if (type_check && param == nullptr)
      mooseError("Failed to get the '",
                 pair.first,
                 "' parameter the supplied template argument must be of type '",
                 pair.second->type(),
                 "'.");
    else if (param != nullptr)
      output.push_back(param->get());
  }
  return output;
}
 
template <typename T>
bool
ControllableItem::check() const
{
  return std::all_of(_pairs.begin(),
                     _pairs.end(),
                     [](std::pair<MooseObjectParameterName, libMesh::Parameters::Value *> pair)
                     {
                       libMesh::Parameters::Parameter<T> * param =
                           dynamic_cast<libMesh::Parameters::Parameter<T> *>(pair.second);
                       return param != nullptr;
                     });
}
 
class ControllableAlias : public ControllableItem
{
public:
  ControllableAlias(const MooseObjectParameterName & name, ControllableItem *);
  virtual const MooseObjectParameterName & name() const override;
  virtual std::string dump(unsigned int indent = 0) const override;
 
private:
  MooseObjectParameterName _name;
};