UserObjectInterface.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
 
// MOOSE includes
#include "MooseTypes.h"
#include "MooseUtils.h"
 
// Forward declarations
class MooseObject;
class UserObjectBase;
class FEProblemBase;
 
class UserObjectInterface
{
public:
  static InputParameters validParams();
 
  UserObjectInterface(const MooseObject * moose_object);
 
#ifdef MOOSE_KOKKOS_ENABLED
  UserObjectInterface(const UserObjectInterface & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  UserObjectName getUserObjectName(const std::string & param_name) const;
 
  bool hasUserObject(const std::string & param_name) const;
  template <class T>
  bool hasUserObject(const std::string & param_name) const;
 
  /*
   * @return Whether or not a UserObject exists with the name \p object_name.
   */
  bool hasUserObjectByName(const UserObjectName & object_name) const;
  template <class T>
  bool hasUserObjectByName(const UserObjectName & object_name) const;
 
  template <class T>
  const T & getUserObject(const std::string & param_name, bool is_dependency = true) const;
 
  template <class T>
  const T & getUserObjectByName(const UserObjectName & object_name,
                                bool is_dependency = true) const;
 
  const UserObjectBase & getUserObjectBase(const std::string & param_name,
                                           bool is_dependency = true) const;
 
  const UserObjectBase & getUserObjectBaseByName(const UserObjectName & object_name,
                                                 bool is_dependency = true) const;
 
protected:
  virtual void addUserObjectDependencyHelper(const UserObjectBase & /* uo */) const {}
 
private:
  const UserObjectBase & getUserObjectFromFEProblem(const UserObjectName & object_name,
                                                    const THREAD_ID tid = 0) const;
 
  template <class T>
  const T & castUserObject(const UserObjectBase & uo_base,
                           const std::string & param_name = "") const;
 
  void mooseObjectError(const std::string & param_name, std::stringstream & oss) const;
 
  const std::string & userObjectType(const UserObjectBase & uo) const;
  const std::string & userObjectName(const UserObjectBase & uo) const;
 
  const MooseObject & _uoi_moose_object;
 
  const FEProblemBase & _uoi_feproblem;
 
  const THREAD_ID _uoi_tid;
};
 
template <class T>
const T &
UserObjectInterface::castUserObject(const UserObjectBase & uo_base,
                                    const std::string & param_name /* = "" */) const
{
  const T * uo = dynamic_cast<const T *>(&uo_base);
 
  if (!uo)
  {
    std::stringstream oss;
    oss << "The provided UserObject \"" << userObjectName(uo_base) << "\" of type "
        << userObjectType(uo_base)
        << " is not derived from the required type.\n\nThe UserObject must derive from "
        << MooseUtils::prettyCppType<T>() << ".";
 
    mooseObjectError(param_name, oss);
  }
 
  return *uo;
}
 
template <class T>
const T &
UserObjectInterface::getUserObject(const std::string & param_name, const bool is_dependency) const
{
  return castUserObject<T>(getUserObjectBase(param_name, is_dependency), param_name);
}
 
template <class T>
const T &
UserObjectInterface::getUserObjectByName(const UserObjectName & object_name,
                                         const bool is_dependency) const
{
  return castUserObject<T>(getUserObjectBaseByName(object_name, is_dependency));
}
 
template <class T>
bool
UserObjectInterface::hasUserObject(const std::string & param_name) const
{
  return hasUserObjectByName<T>(getUserObjectName(param_name));
}
 
template <class T>
bool
UserObjectInterface::hasUserObjectByName(const UserObjectName & object_name) const
{
  if (!hasUserObjectByName(object_name))
    return false;
  return dynamic_cast<const T *>(&getUserObjectFromFEProblem(object_name));
}