MeshMetaDataInterface.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 "MooseError.h"
#include "RestartableData.h"
#include "MooseObject.h"
 
#include <string>
 
class MeshGenerator;
 
class MeshMetaDataInterface
{
public:
  static constexpr auto SYSTEM = "MeshMetaData";
 
  static constexpr auto NAME = "<empty>";
 
protected:
  MeshMetaDataInterface(const MooseObject * moose_object);
 
  MeshMetaDataInterface(MooseApp & moose_app);
 
#ifdef MOOSE_KOKKOS_ENABLED
  MeshMetaDataInterface(const MeshMetaDataInterface & object,
                        const Moose::Kokkos::FunctorCopy & key);
#endif
 
  template <typename T>
  const T & getMeshProperty(const std::string & data_name, const std::string & prefix);
  template <typename T>
  const T & getMeshProperty(const std::string & data_name)
  {
    return getMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
  }
 
  bool hasMeshProperty(const std::string & data_name, const std::string & prefix) const;
  template <typename T>
  bool hasMeshProperty(const std::string & data_name, const std::string & prefix) const;
 
  bool hasMeshProperty(const std::string & data_name) const
  {
    return hasMeshProperty(data_name, meshPropertyPrefix(data_name));
  }
  template <typename T>
  bool hasMeshProperty(const std::string & data_name) const
  {
    return hasMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
  }
 
  static std::string meshPropertyName(const std::string & data_name, const std::string & prefix);
 
  std::string meshPropertyName(const std::string & data_name) const
  {
    return meshPropertyName(data_name, meshPropertyPrefix(data_name));
  }
 
private:
  virtual std::string meshPropertyPrefix(const std::string & data_name) const;
 
  const RestartableDataValue & getMeshPropertyInternal(const std::string & data_name,
                                                       const std::string & prefix) const;
 
  MooseApp & _meta_data_app;
 
  const MooseObject * const _meta_data_object;
 
  template <typename... Args>
  [[noreturn]] void mooseErrorInternal(Args &&... args) const
  {
    if (_meta_data_object)
      _meta_data_object->mooseError(std::forward<Args>(args)...);
    mooseError(std::forward<Args>(args)...);
  }
};
 
template <typename T>
const T &
MeshMetaDataInterface::getMeshProperty(const std::string & data_name, const std::string & prefix)
 
{
  if (!hasMeshProperty(data_name, prefix))
    mooseErrorInternal("Failed to get mesh property '", prefix, "/", data_name, "'");
 
  auto value = &getMeshPropertyInternal(data_name, prefix);
  mooseAssert(value->declared(), "Value has not been declared");
  const RestartableData<T> * T_value = dynamic_cast<const RestartableData<T> *>(value);
  if (!T_value)
    mooseErrorInternal("While retrieving mesh property '",
                       prefix,
                       "/",
                       data_name,
                       "' with type '",
                       MooseUtils::prettyCppType<T>(),
                       "',\nthe property exists with different type '",
                       value->type(),
                       "'");
  return T_value->get();
}
 
template <typename T>
bool
MeshMetaDataInterface::hasMeshProperty(const std::string & data_name,
                                       const std::string & prefix) const
{
  if (!hasMeshProperty(data_name, prefix))
    return false;
  const auto & value = getMeshPropertyInternal(data_name, prefix);
  return dynamic_cast<const RestartableData<T> *>(&value) != nullptr;
}