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 UserObject;
class FEProblemBase;
class MooseObject;

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 UserObject & getUserObjectBase(const std::string & param_name,
                                       bool is_dependency = true) const;

  const UserObject & getUserObjectBaseByName(const UserObjectName & object_name,
                                             bool is_dependency = true) const;

protected:
  virtual void addUserObjectDependencyHelper(const UserObject & /* uo */) const {}

private:
  const UserObject & getUserObjectFromFEProblem(const UserObjectName & object_name) const;

  template <class T>
  const T & castUserObject(const UserObject & uo_base, const std::string & param_name = "") const;

  void mooseObjectError(const std::string & param_name, std::stringstream & oss) const;

  const std::string & userObjectType(const UserObject & uo) const;
  const std::string & userObjectName(const UserObject & uo) const;

  const MooseObject & _uoi_moose_object;

  const FEProblemBase & _uoi_feproblem;

  const THREAD_ID _uoi_tid;
};

template <class T>
const T &
UserObjectInterface::castUserObject(const UserObject & 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));
}