MooseError.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 "Moose.h"
#include "MooseException.h"
#include "libmesh/threads.h"

#include "libmesh/print_trace.h"
#include "libmesh/libmesh_common.h"

// C++ includes
#include <cstdlib>
#include <tuple>
#include <type_traits>

// Used in numerous downstream classes without 'libMesh::' prefix
using libMesh::demangle;

namespace MetaPhysicL
{
class LogicError;
}

namespace hit
{
class Node;
}

// this function allows streaming tuples to ostreams
template <size_t n, typename... T>
void
print_tuple(std::ostream & os, const std::tuple<T...> & tup)
{
  if constexpr (n < sizeof...(T))
  {
    if (n != 0)
      os << ", ";
    os << std::get<n>(tup);
    print_tuple<n + 1>(os, tup);
  }
}
template <typename... T>
std::ostream &
operator<<(std::ostream & os, const std::tuple<T...> & tup)
{
  os << "[";
  print_tuple<0>(os, tup);
  return os << "]";
}

#if defined(LIBMESH_HAVE_MPI)
#define MOOSE_ABORT                                                                                \
  do                                                                                               \
  {                                                                                                \
    MPI_Abort(libMesh::GLOBAL_COMM_WORLD, 1);                                                      \
    std::abort();                                                                                  \
  } while (0)
#else
#define MOOSE_ABORT                                                                                \
  do                                                                                               \
  {                                                                                                \
    std::abort();                                                                                  \
  } while (0)
#endif

#define mooseDoOnce(do_this)                                                                       \
  do                                                                                               \
  {                                                                                                \
    static bool did_this_already = false;                                                          \
    if (Moose::show_multiple || !did_this_already)                                                 \
    {                                                                                              \
      did_this_already = true;                                                                     \
      do_this;                                                                                     \
    }                                                                                              \
  } while (0)

#define mooseCheckMPIErr(err)                                                                      \
  do                                                                                               \
  {                                                                                                \
    if (err != MPI_SUCCESS)                                                                        \
      moose::internal::mooseErrorRaw("");                                                          \
  } while (0)

#define mooseException(...)                                                                        \
  do                                                                                               \
  {                                                                                                \
    throw MooseException(__VA_ARGS__);                                                             \
  } while (0)

#ifdef NDEBUG
#define mooseAssert(asserted, msg) ((void)0)
#else
#define mooseAssert(asserted, msg)                                                                 \
  do                                                                                               \
  {                                                                                                \
    if (!(asserted))                                                                               \
    {                                                                                              \
      std::ostringstream _assert_oss_;                                                             \
      _assert_oss_ << COLOR_RED << "\n\nAssertion `" #asserted "' failed\n"                        \
                   << msg << "\nat " << __FILE__ << ", line " << __LINE__ << COLOR_DEFAULT         \
                   << std::endl;                                                                   \
      if (Moose::_throw_on_error)                                                                  \
        throw std::runtime_error(_assert_oss_.str());                                              \
      else                                                                                         \
      {                                                                                            \
        Moose::err << _assert_oss_.str() << std::flush;                                            \
        moose::internal::mooseErrorRaw("");                                                        \
      }                                                                                            \
    }                                                                                              \
  } while (0)
#endif

template <typename... Args>
[[noreturn]] void mooseError(Args &&... args);

class MooseRuntimeError : public std::runtime_error
{
public:
  MooseRuntimeError(const std::string & message, const hit::Node * const node)
    : runtime_error(message), _node(node)
  {
  }

  const hit::Node * getNode() const { return _node; }

private:
  const hit::Node * const _node;
};

class MooseVariableFieldBase;

namespace moose
{

namespace internal
{
inline libMesh::Threads::spin_mutex moose_stream_lock;

std::string incompatVarMsg(MooseVariableFieldBase & var1, MooseVariableFieldBase & var2);

std::string
mooseMsgFmt(const std::string & msg, const std::string & title, const std::string & color);

std::string mooseMsgFmt(const std::string & msg, const std::string & color);

[[noreturn]] void
mooseErrorRaw(std::string msg, const std::string & prefix = "", const hit::Node * node = nullptr);

void mooseStreamAll(std::ostringstream & ss);

template <typename T, typename... Args>
void
mooseStreamAll(std::ostringstream & ss, T && val, Args &&... args)
{
  ss << val;
  mooseStreamAll(ss, std::forward<Args>(args)...);
}

template <typename S, typename... Args>
void
mooseWarningStream(S & oss, Args &&... args)
{
  if (Moose::_warnings_are_errors)
    mooseError(std::forward<Args>(args)...);

  std::ostringstream ss;
  mooseStreamAll(ss, args...);
  std::string msg = mooseMsgFmt(ss.str(), "*** Warning ***", COLOR_YELLOW);
  if (Moose::_throw_on_warning)
    throw std::runtime_error(msg);

  {
    libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
    oss << msg << std::flush;
  }
}

template <typename S, typename... Args>
void
mooseUnusedStream(S & oss, Args &&... args)
{
  std::ostringstream ss;
  mooseStreamAll(ss, args...);
  std::string msg = mooseMsgFmt(ss.str(), "*** Warning ***", COLOR_YELLOW);
  if (Moose::_throw_on_warning)
    throw std::runtime_error(msg);

  {
    libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
    oss << msg << std::flush;
  }
}

template <typename S, typename... Args>
void
mooseInfoStreamRepeated(S & oss, Args &&... args)
{
  std::ostringstream ss;
  mooseStreamAll(ss, args...);
  std::string msg = mooseMsgFmt(ss.str(), "*** Info ***", COLOR_CYAN);
  {
    libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
    oss << msg << std::flush;
  }
}

template <typename S, typename... Args>
void
mooseInfoStream(S & oss, Args &&... args)
{
  mooseDoOnce(mooseInfoStreamRepeated(oss, args...););
}

template <typename S, typename... Args>
void
mooseDeprecatedStream(S & oss, const bool expired, const bool print_title, Args &&... args)
{
  if (Moose::_deprecated_is_error)
    mooseError("\n\nDeprecated code:\n", std::forward<Args>(args)...);

  std::ostringstream ss;
  mooseStreamAll(ss, args...);

  const auto color = expired ? COLOR_RED : COLOR_YELLOW;
  std::string msg = print_title ? mooseMsgFmt(ss.str(), "*** Deprecation Warning ***", color)
                                : mooseMsgFmt(ss.str(), color);
  oss << msg;
  ss.str("");
  if (Moose::show_trace)
  {
    if (libMesh::global_n_processors() == 1)
      libMesh::print_trace(ss);
    else
      libMesh::write_traceout();
    {
      libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
      oss << ss.str() << std::endl;
    };
  };
}
std::string formatMooseDocumentedError(const std::string & repo_name,
                                       const unsigned int issue_num,
                                       const std::string & msg);
} // namespace internal

void translateMetaPhysicLError(const MetaPhysicL::LogicError &);

} // namespace moose

template <typename... Args>
[[noreturn]] void
mooseError(Args &&... args)
{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  moose::internal::mooseErrorRaw(oss.str());
}

template <typename... Args>
[[noreturn]] void
mooseDocumentedError(const std::string & repo_name, const unsigned int issue_num, Args &&... args)
{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  moose::internal::mooseErrorRaw(
      moose::internal::formatMooseDocumentedError(repo_name, issue_num, oss.str()));
}

template <typename... Args>
void
mooseWarning(Args &&... args)
{
  moose::internal::mooseWarningStream(Moose::out, std::forward<Args>(args)...);
}

template <typename... Args>
void
mooseUnused(Args &&... args)
{
  moose::internal::mooseUnusedStream(Moose::out, std::forward<Args>(args)...);
}

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

template <typename... Args>
void
mooseDeprecationExpired(Args &&... args)
{
  moose::internal::mooseDeprecatedStream(Moose::out, true, true, std::forward<Args>(args)...);
}

template <typename... Args>
void
mooseInfo(Args &&... args)
{
  moose::internal::mooseInfoStream(Moose::out, std::forward<Args>(args)...);
}

template <typename... Args>
void
mooseInfoRepeated(Args &&... args)
{
  moose::internal::mooseInfoStreamRepeated(Moose::out, std::forward<Args>(args)...);
}