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;
}