ChainControl.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 "Control.h"
#include "ChainControlData.h"
#include "ChainControlDataSystem.h"
#include "MooseUtils.h"

class ChainControl : public Control
{
public:
  static InputParameters validParams();

  ChainControl(const InputParameters & parameters);

  virtual void init() {}

  const std::vector<std::string> & getChainControlDataDependencies() const
  {
    return _control_data_depends_on;
  }

protected:
  template <typename T>
  T & declareChainControlData(const std::string & data_name, bool apply_object_prefix = true);

  template <typename T>
  const T & getChainControlData(const std::string & param);

  template <typename T>
  const T & getChainControlDataOld(const std::string & param);

  template <typename T>
  const T & getChainControlDataByName(const std::string & data_name);

  template <typename T>
  const T & getChainControlDataOldByName(const std::string & data_name);

  void addChainControlDataDependency(const std::string & data_name);

  std::string fullControlDataName(const std::string & data_name,
                                  bool apply_object_prefix = true) const;

  std::vector<std::string> _control_data_depends_on;

private:
  ChainControlDataSystem & getChainControlDataSystem();
};

template <typename T>
T &
ChainControl::declareChainControlData(const std::string & data_name, bool apply_object_prefix)
{
  const std::string full_data_name = fullControlDataName(data_name, apply_object_prefix);
  auto & data = getChainControlDataSystem().declareChainControlData<T>(full_data_name, *this);
  return data.set();
}

template <typename T>
const T &
ChainControl::getChainControlData(const std::string & param)
{
  return getChainControlDataByName<T>(getParam<std::string>(param));
}

template <typename T>
const T &
ChainControl::getChainControlDataOld(const std::string & param)
{
  return getChainControlDataOldByName<T>(getParam<std::string>(param));
}

template <typename T>
const T &
ChainControl::getChainControlDataByName(const std::string & data_name)
{
  auto & system = getChainControlDataSystem();

  if (system.hasChainControlData(data_name) && !system.hasChainControlDataOfType<T>(data_name))
    mooseError("The chain control data '",
               data_name,
               "' has the type '",
               system.getChainControlDataMap().at(data_name)->type(),
               "', but this chain control requires its type to be '",
               MooseUtils::prettyCppType<T>(),
               "'.");

  auto & data = system.getChainControlData<T>(data_name);

  addChainControlDataDependency(data_name);

  return data.get();
}

template <typename T>
const T &
ChainControl::getChainControlDataOldByName(const std::string & data_name)
{
  auto & data = getChainControlDataSystem().getChainControlData<T>(data_name);

  return data.getOld();
}