MooseBase.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 "ConsoleStreamInterface.h"
#include "StreamArguments.h"
#include "InputParameters.h"
#include "MooseError.h"
#include "MooseObjectName.h"
#include "MooseObjectParameterName.h"

class MooseApp;

namespace hit
{
class Node;
}

#define usingMooseBaseMembers                                                                      \
  using MooseBase::getMooseApp;                                                                    \
  using MooseBase::type;                                                                           \
  using MooseBase::name;                                                                           \
  using MooseBase::typeAndName;                                                                    \
  using MooseBase::uniqueName;                                                                     \
  using MooseBase::parameters;                                                                     \
  using MooseBase::isParamValid;                                                                   \
  using MooseBase::isParamSetByUser;                                                               \
  using MooseBase::paramError;                                                                     \
  using MooseBase::paramWarning;                                                                   \
  using MooseBase::paramInfo;                                                                      \
  using MooseBase::_app;                                                                           \
  using MooseBase::_type;                                                                          \
  using MooseBase::_name;                                                                          \
  using MooseBase::_pars

class MooseBase : public ConsoleStreamInterface
{
public:
  static const std::string type_param;
  static const std::string name_param;
  static const std::string unique_name_param;
  static const std::string app_param;
  static const std::string moose_base_param;
#ifdef MOOSE_KOKKOS_ENABLED
  static const std::string kokkos_object_param;
#endif

  static InputParameters validParams();

  MooseBase(const InputParameters & params);

  MooseBase(MooseApp & app, const InputParameters & params);

  virtual ~MooseBase() = default;

  MooseApp & getMooseApp() const { return _app; }

  const std::string & type() const
  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

  const std::string & name() const
  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

  std::string typeAndName() const;

  MooseObjectParameterName uniqueParameterName(const std::string & parameter_name) const;

  MooseObjectName uniqueName() const;

  const InputParameters & parameters() const { return _pars; }

  const hit::Node * getHitNode() const { return getHitNode(_pars); }

  bool hasBase() const { return _pars.hasBase(); }

  const std::string & getBase() const { return _pars.getBase(); }

  template <typename T>
  const T & getParam(const std::string & name) const;

  template <typename T>
  const T * queryParam(const std::string & name) const;

  template <typename T>
  const T & getRenamedParam(const std::string & old_name, const std::string & new_name) const;

  template <typename T1, typename T2>
  std::vector<std::pair<T1, T2>> getParam(const std::string & param1,
                                          const std::string & param2) const;

  template <typename T>
  T getCheckedPointerParam(const std::string & name, const std::string & error_string = "") const;

  template <typename T>
  inline bool haveParameter(const std::string & name) const
  {
    return _pars.have_parameter<T>(name);
  }

  inline bool isParamValid(const std::string & name) const { return _pars.isParamValid(name); }

  inline bool isParamSetByUser(const std::string & name) const
  {
    return _pars.isParamSetByUser(name);
  }

  void connectControllableParams(const std::string & parameter,
                                 const std::string & object_type,
                                 const std::string & object_name,
                                 const std::string & object_parameter) const;

  template <typename... Args>
  [[noreturn]] void paramError(const std::string & param, Args... args) const;

  template <typename... Args>
  void paramWarning(const std::string & param, Args... args) const;

  template <typename... Args>
  void paramInfo(const std::string & param, Args... args) const;

  std::string messagePrefix(const bool hit_prefix = true) const
  {
    return messagePrefix(_pars, hit_prefix);
  }

  std::string errorPrefix(const std::string &) const { return messagePrefix(); }

  template <typename... Args>
  [[noreturn]] void mooseError(Args &&... args) const
  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
  }

  template <typename... Args>
  [[noreturn]] void mooseDocumentedError(const std::string & repo_name,
                                         const unsigned int issue_num,
                                         Args &&... args) const
  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

  template <typename... Args>
  [[noreturn]] void mooseErrorNonPrefixed(Args &&... args) const
  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
  }

  template <typename... Args>
  void mooseWarning(Args &&... args) const
  {
    moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

  template <typename... Args>
  void mooseWarningNonPrefixed(Args &&... args) const
  {
    moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
  }

  template <typename... Args>
  void mooseDeprecated(Args &&... args) const
  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
  }

  template <typename... Args>
  void mooseDeprecatedNoTrace(Args &&... args) const
  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, false, messagePrefix(true), std::forward<Args>(args)...);
  }

  template <typename... Args>
  void mooseInfo(Args &&... args) const
  {
    moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

  [[noreturn]] void callMooseError(std::string msg,
                                   const bool with_prefix,
                                   const hit::Node * node = nullptr,
                                   const bool show_trace = true) const;

  [[noreturn]] static void callMooseError(MooseApp * const app,
                                          const InputParameters & params,
                                          std::string msg,
                                          const bool with_prefix,
                                          const hit::Node * node,
                                          const bool show_trace = true);

protected:
  MooseApp & _app;

  const std::string & _type;

  const std::string & _name;

  const InputParameters & _pars;

private:
  static std::string messagePrefix(const InputParameters & params, const bool hit_prefix);

  static const hit::Node * getHitNode(const InputParameters & params);
};

template <typename T>
const T &
MooseBase::getParam(const std::string & name) const
{
  return InputParameters::getParamHelper<T>(name, _pars);
}

template <typename T>
const T *
MooseBase::queryParam(const std::string & name) const
{
  return haveParameter<T>(name) && isParamValid(name) ? &getParam<T>(name) : nullptr;
}

template <typename T>
const T &
MooseBase::getRenamedParam(const std::string & old_name, const std::string & new_name) const
{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

template <typename T1, typename T2>
std::vector<std::pair<T1, T2>>
MooseBase::getParam(const std::string & param1, const std::string & param2) const
{
  return _pars.get<T1, T2>(param1, param2);
}

template <typename T>
T
MooseBase::getCheckedPointerParam(const std::string & name, const std::string & error_string) const
{
  return _pars.getCheckedPointerParam<T>(name, error_string);
}

template <typename... Args>
[[noreturn]] void
MooseBase::paramError(const std::string & param, Args... args) const
{
  _pars.paramError(param, std::forward<Args>(args)...);
}

template <typename... Args>
void
MooseBase::paramWarning(const std::string & param, Args... args) const
{
  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
}

template <typename... Args>
void
MooseBase::paramInfo(const std::string & param, Args... args) const
{
  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
}