exceptions.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 1998 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_exceptions_h
#define dealii_exceptions_h
 
#include <deal.II/base/config.h>
 
// The exception machinery (including the macros defined in
// exception_macros.h) references Kokkos functions. The places that
// use exceptions must know about these functions, and to avoid them
// all having to include Kokkos headers, we have to do it here:
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
#include <Kokkos_Macros.hpp>
#if DEAL_II_KOKKOS_VERSION_GTE(4, 2, 0)
#  include <Kokkos_Abort.hpp>
#else
#  include <Kokkos_Core.hpp>
#endif
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
 
 
#include <deal.II/base/exception_macros.h>
 
#include <exception>
#include <ostream>
#include <string>
#include <type_traits>
 
DEAL_II_NAMESPACE_OPEN
 
 
class ExceptionBase : public std::exception
{
public:
  ExceptionBase();
 
  ExceptionBase(const ExceptionBase &exc);
 
  virtual ~ExceptionBase() noexcept override = default;
 
  ExceptionBase
  operator=(const ExceptionBase &) = delete;
 
  void
  set_fields(const char *file,
             const int   line,
             const char *function,
             const char *cond,
             const char *exc_name);
 
 
  virtual const char *
  what() const noexcept override;
 
  const char *
  get_exc_name() const;
 
  void
  print_exc_data(std::ostream &out) const;
 
  virtual void
  print_info(std::ostream &out) const;
 
  void
  print_stack_trace(std::ostream &out) const;
 
protected:
  const char *file;
 
  unsigned int line;
 
  const char *function;
 
  const char *cond;
 
  const char *exc;
 
  int n_stacktrace_frames;
 
#ifdef DEAL_II_HAVE_GLIBC_STACKTRACE
  void *raw_stacktrace[25];
#endif
 
private:
  void
  generate_message() const;
 
  mutable std::string what_str;
};
 
 
namespace StandardExceptions
{
  DeclExceptionMsg(ExcDivideByZero,
                   "A piece of code is attempting a division by zero. This is "
                   "likely going to lead to results that make no sense.");
 
  template <typename Number>
  DeclException1(
    ExcNumberNotFinite,
    Number,
    << "In a significant number of places, deal.II checks that some intermediate "
    << "value is a finite number (as opposed to plus or minus infinity, or "
    << "NaN/Not a Number). In the current function, we encountered a number "
    << "that is not finite (its value is " << arg1 << " and therefore "
    << "violates the current assertion).\n\n"
    << "This may be due to the fact that some operation in this function "
    << "created such a value, or because one of the arguments you passed "
    << "to the function already had this value from some previous "
    << "operation. In the latter case, this function only triggered the "
    << "error but may not actually be responsible for the computation of "
    << "the number that is not finite.\n\n"
    << "There are two common cases where this situation happens. First, your "
    << "code (or something in deal.II) divides by zero in a place where this "
    << "should not happen. Or, you are trying to solve a linear system "
    << "with an unsuitable solver (such as an indefinite or non-symmetric "
    << "linear system using a Conjugate Gradient solver); such attempts "
    << "oftentimes yield an operation somewhere that tries to divide "
    << "by zero or take the square root of a negative value.\n\n"
    << "In any case, when trying to find the source of the error, "
    << "recall that the location where you are getting this error is "
    << "simply the first place in the program where there is a check "
    << "that a number (e.g., an element of a solution vector) is in fact "
    << "finite, but that the actual error that computed the number "
    << "may have happened far earlier. To find this location, you "
    << "may want to add checks for finiteness in places of your "
    << "program visited before the place where this error is produced. "
    << "One way to check for finiteness is to use the 'AssertIsFinite' "
    << "macro.");
 
  DeclException1(ExcOutOfMemory,
                 std::size_t,
                 "Your program tried to allocate some memory but this "
                 "allocation failed. Typically, this either means that "
                 "you simply do not have enough memory in your system, "
                 "or that you are (erroneously) trying to allocate "
                 "a chunk of memory that is simply beyond all reasonable "
                 "size, for example because the size of the object has "
                 "been computed incorrectly."
                 "\n\n"
                 "In the current case, the request was for "
                   << arg1 << " bytes.");
 
  DeclException1(ExcMemoryLeak,
                 int,
                 << "Destroying memory handler while " << arg1
                 << " objects are still allocated.");
 
  DeclExceptionMsg(ExcIO,
                   "An input/output error has occurred. There are a number of "
                   "reasons why this may be happening, both for reading and "
                   "writing operations."
                   "\n\n"
                   "If this happens during an operation that tries to read "
                   "data: First, you may be "
                   "trying to read from a file that doesn't exist or that is "
                   "not readable given its file permissions. Second, deal.II "
                   "uses this error at times if it tries to "
                   "read information from a file but where the information "
                   "in the file does not correspond to the expected format. "
                   "An example would be a truncated file, or a mesh file "
                   "that contains not only sections that describe the "
                   "vertices and cells, but also sections for additional "
                   "data that deal.II does not understand."
                   "\n\n"
                   "If this happens during an operation that tries to write "
                   "data: you may be trying to write to a file to which file "
                   "or directory permissions do not allow you to write. A "
                   "typical example is where you specify an output file in "
                   "a directory that does not exist.");
 
  DeclException1(ExcFileNotOpen,
                 std::string,
                 << "Could not open file " << arg1
                 << "."
                    "\n\n"
                    "If this happens during an operation that tries to read "
                    "data: you may be "
                    "trying to read from a file that doesn't exist or that is "
                    "not readable given its file permissions."
                    "\n\n"
                    "If this happens during an operation that tries to write "
                    "data: you may be trying to write to a file to which file "
                    "or directory permissions do not allow you to write. A "
                    "typical example is where you specify an output file in "
                    "a directory that does not exist.");
 
  DeclExceptionMsg(ExcNotImplemented,
                   "You are trying to use functionality in deal.II that is "
                   "currently not implemented. In many cases, this indicates "
                   "that there simply didn't appear much of a need for it, or "
                   "that the author of the original code did not have the "
                   "time to implement a particular case. If you hit this "
                   "exception, it is therefore worth the time to look into "
                   "the code to find out whether you may be able to "
                   "implement the missing functionality. If you do, please "
                   "consider providing a patch to the deal.II development "
                   "sources (see the deal.II website on how to contribute).");
 
  DeclExceptionMsg(ExcInternalError,
                   "This exception -- which is used in many places in the "
                   "library -- usually indicates that some condition which "
                   "the author of the code thought must be satisfied at a "
                   "certain point in an algorithm, is not fulfilled. An "
                   "example would be that the first part of an algorithm "
                   "sorts elements of an array in ascending order, and "
                   "a second part of the algorithm later encounters an "
                   "element that is not larger than the previous one."
                   "\n\n"
                   "There is usually not very much you can do if you "
                   "encounter such an exception since it indicates an error "
                   "in deal.II, not in your own program. Try to come up with "
                   "the smallest possible program that still demonstrates "
                   "the error and contact the deal.II mailing lists with it "
                   "to obtain help.");
 
  DeclExceptionMsg(
    ExcPureFunctionCalled,
    "You (or a place in the library) are trying to call a "
    "function that is declared as a virtual function in a "
    "base class but that has not been overridden in your "
    "derived class."
    "\n\n"
    "This exception happens in cases where the base class "
    "cannot provide a useful default implementation for "
    "the virtual function, but where we also do not want "
    "to mark the function as abstract (i.e., with '=0' at the end) "
    "because the function is not essential to the class in many "
    "contexts. In cases like this, the base class provides "
    "a dummy implementation that makes the compiler happy, but "
    "that then throws the current exception."
    "\n\n"
    "A concrete example would be the 'Function' class. It declares "
    "the existence of 'value()' and 'gradient()' member functions, "
    "and both are marked as 'virtual'. Derived classes have to "
    "override these functions for the values and gradients of a "
    "particular function. On the other hand, not every function "
    "has a gradient, and even for those that do, not every program "
    "actually needs to evaluate it. Consequently, there is no "
    "*requirement* that a derived class actually override the "
    "'gradient()' function (as there would be had it been marked "
    "as abstract). But, since the base class cannot know how to "
    "compute the gradient, if a derived class does not override "
    "the 'gradient()' function and it is called anyway, then the "
    "default implementation in the base class will simply throw "
    "an exception."
    "\n\n"
    "The exception you see is what happens in cases such as the "
    "one just illustrated. To fix the problem, you need to "
    "investigate whether the function being called should indeed have "
    "been called; if the answer is 'yes', then you need to "
    "implement the missing override in your class.");
 
  DeclException1(ExcFunctionNotProvided,
                 std::string,
                 << "Please provide an implementation for the function \""
                 << arg1 << "\"");
 
  DeclException2(
    ExcFunctionNonzeroReturn,
    std::string,
    int,
    << "The function \"" << arg1 << "\" returned the nonzero value " << arg2
    << ", but the calling site expected the return value to be zero. "
       "This error often happens when the function in question is a 'callback', "
       "that is a user-provided function called from somewhere within deal.II "
       "or within an external library such as PETSc, Trilinos, SUNDIALS, etc., "
       "that expect these callbacks to indicate errors via nonzero return "
       "codes.");
 
  DeclException0(ExcNotInitialized);
 
  DeclException0(ExcInvalidState);
 
  DeclException1(ExcImpossibleInDim,
                 int,
                 << "You are trying to execute functionality that is "
                 << "impossible in " << arg1
                 << "d or simply does not make any sense.");
 
  DeclException2(ExcImpossibleInDimSpacedim,
                 int,
                 int,
                 << "You are trying to execute functionality that is "
                 << "impossible in dimensions <" << arg1 << ',' << arg2
                 << "> or simply does not make any sense.");
 
 
  DeclExceptionMsg(ExcZero,
                   "In a check in the code, deal.II encountered a zero in "
                   "a place where this does not make sense. See the condition "
                   "that was being checked and that is printed further up "
                   "in the error message to get more information on what "
                   "the erroneous zero corresponds to.");
 
  DeclExceptionMsg(ExcEmptyObject,
                   "The object you are trying to access is empty but it makes "
                   "no sense to attempt the operation you are trying on an "
                   "empty object.");
 
  DeclException2(ExcDimensionMismatch,
                 std::size_t,
                 std::size_t,
                 << "Two sizes or dimensions were supposed to be equal, "
                 << "but aren't. They are " << arg1 << " and " << arg2 << '.');
 
  DeclException2(
    ExcInvalidIntegerConversion,
    long long,
    long long,
    << "Two integers should be equal to each other after a type conversion but "
    << "aren't. A typical cause of this problem is that the integral types "
    << "used by deal.II and an external library are different (e.g., one uses "
    << "32-bit integers and the other uses 64-bit integers). The integers are "
    << arg1 << " and " << arg2 << '.');
 
  DeclException3(ExcDimensionMismatch2,
                 std::size_t,
                 std::size_t,
                 std::size_t,
                 << "The size or dimension of one object, " << arg1
                 << " was supposed to be "
                 << "equal to one of two values, but isn't. The two possible "
                 << "values are " << arg2 << " and " << arg3 << '.');
 
  DeclException3(
    ExcIndexRange,
    std::size_t,
    std::size_t,
    std::size_t,
    << "Index " << arg1 << " is not in the half-open range [" << arg2 << ','
    << arg3 << ")."
    << (arg2 == arg3 ?
          " In the current case, this half-open range is in fact empty, "
          "suggesting that you are accessing an element of an empty "
          "collection such as a vector that has not been set to the "
          "correct size." :
          ""));
 
  template <typename T>
  DeclException3(
    ExcIndexRangeType,
    T,
    T,
    T,
    << "Index " << arg1 << " is not in the half-open range [" << arg2 << ','
    << arg3 << ")."
    << (arg2 == arg3 ?
          " In the current case, this half-open range is in fact empty, "
          "suggesting that you are accessing an element of an empty "
          "collection such as a vector that has not been set to the "
          "correct size." :
          ""));
 
  DeclException2(ExcLowerRange,
                 int,
                 int,
                 << "Number " << arg1 << " must be larger than or equal "
                 << arg2 << '.');
 
  template <typename T>
  DeclException2(ExcLowerRangeType,
                 T,
                 T,
                 << "Number " << arg1 << " must be larger than or equal "
                 << arg2 << '.');
 
  DeclException2(ExcNotMultiple,
                 int,
                 int,
                 << "Division " << arg1 << " by " << arg2
                 << " has remainder different from zero.");
 
  DeclExceptionMsg(ExcInvalidIterator,
                   "You are trying to use an iterator, but the iterator is "
                   "in an invalid state. This may indicate that the iterator "
                   "object has not been initialized, or that it has been "
                   "moved beyond the end of the range of valid elements.");
 
  DeclExceptionMsg(ExcIteratorPastEnd,
                   "You are trying to use an iterator, but the iterator is "
                   "pointing past the end of the range of valid elements. "
                   "It is not valid to dereference the iterator in this "
                   "case.");
 
  DeclException1(ExcMessage, std::string, << arg1);
 
  DeclExceptionMsg(ExcGhostsPresent,
                   "You are trying an operation on a vector that is only "
                   "allowed if the vector has no ghost elements, but the "
                   "vector you are operating on does have ghost elements."
                   "\n\n"
                   "Specifically, there are two kinds of operations that "
                   "are typically not allowed on vectors with ghost elements. "
                   "First, vectors with ghost elements are read-only "
                   "and cannot appear in operations that write into these "
                   "vectors with the exception of setting the entire vector "
                   "to zero. Second, reduction operations (such as computing "
                   "the norm of a vector, or taking dot products between "
                   "vectors) are not allowed to ensure that each vector "
                   "element is counted only once (as opposed to once for "
                   "the owner of the element plus once for each process "
                   "on which the element is stored as a ghost copy)."
                   "\n\n"
                   "See the glossary entry on 'Ghosted vectors' for more "
                   "information.");
 
  DeclException1(ExcGridHasInvalidCell,
                 int,
                 << "Something went wrong when making cell " << arg1
                 << ". Read the docs and the source code "
                 << "for more information.");
 
  DeclExceptionMsg(
    ExcInconsistentCoarseningFlags,
    "A cell is flagged for coarsening, but either not all of its siblings "
    "are active or flagged for coarsening as well. Please clean up all "
    "coarsen flags on your triangulation via "
    "Triangulation::prepare_coarsening_and_refinement() beforehand!");
 
  DeclExceptionMsg(ExcScalarAssignmentOnlyForZeroValue,
                   "You are trying an operation of the form 'vector = C', "
                   "'matrix = C', or 'tensor = C' with a nonzero scalar value "
                   "'C'. However, such assignments are only allowed if the "
                   "C is zero, since the semantics for assigning any other "
                   "value are not clear. For example: one could interpret "
                   "assigning a matrix a value of 1 to mean the matrix has a "
                   "norm of 1, the matrix is the identity matrix, or the "
                   "matrix contains only 1s. Similar problems exist with "
                   "vectors and tensors. Hence, to avoid this ambiguity, such "
                   "assignments are not permitted.");
 
  DeclExceptionMsg(
    ExcNeedsLAPACK,
    "You are attempting to use functionality that is only available "
    "if deal.II was configured to use LAPACK, but when you configured "
    "the library, cmake did not find a valid LAPACK library."
    "\n\n"
    "You will have to ensure that your system has a usable LAPACK "
    "installation and re-install deal.II, making sure that cmake "
    "finds the LAPACK installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
  DeclExceptionMsg(
    ExcNeedsHDF5,
    "You are attempting to use functionality that requires that deal.II is configured "
    "with HDF5 support. However, when you called 'cmake', HDF5 support "
    "was not detected."
    "\n\n"
    "You will have to ensure that your system has a usable HDF5 "
    "installation and re-install deal.II, making sure that cmake "
    "finds the HDF5 installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
  DeclExceptionMsg(
    ExcNeedsNetCDF,
    "You are attempting to use functionality that requires that deal.II is configured "
    "with NetCDF support. However, when you called 'cmake', NetCDF support "
    "was not detected."
    "\n\n"
    "You will have to ensure that your system has a usable NetCDF "
    "installation and re-install deal.II, making sure that cmake "
    "finds the NetCDF installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
  DeclExceptionMsg(
    ExcNeedsMPI,
    "You are attempting to use functionality that is only available "
    "if deal.II was configured to use MPI."
    "\n\n"
    "You will have to ensure that your system has a usable MPI "
    "installation and re-install deal.II, making sure that cmake "
    "finds the MPI installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
  DeclExceptionMsg(
    ExcNeedsFunctionparser,
    "You are attempting to use functionality that is only available "
    "if deal.II was configured to use the function parser which "
    "relies on the muparser library, but cmake did not "
    "find a valid muparser library on your system and also did "
    "not choose the one that comes bundled with deal.II."
    "\n\n"
    "You will have to ensure that your system has a usable muparser "
    "installation and re-install deal.II, making sure that cmake "
    "finds the muparser installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
 
  DeclExceptionMsg(
    ExcNeedsAssimp,
    "You are attempting to use functionality that is only available "
    "if deal.II was configured to use Assimp, but cmake did not "
    "find a valid Assimp library."
    "\n\n"
    "You will have to ensure that your system has a usable Assimp "
    "installation and re-install deal.II, making sure that cmake "
    "finds the Assimp installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
  DeclExceptionMsg(
    ExcNeedsExodusII,
    "You are attempting to use functionality that is only available if deal.II "
    "was configured to use Trilinos' SEACAS library (which provides ExodusII), "
    "but cmake did not find a valid SEACAS library."
    "\n\n"
    "You will have to ensure that your system has a usable ExodusII "
    "installation and re-install deal.II, making sure that cmake "
    "finds the ExodusII installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
  DeclExceptionMsg(
    ExcNeedsCGAL,
    "You are attempting to use functionality that is only available "
    "if deal.II was configured to use CGAL, but cmake did not "
    "find a valid CGAL library."
    "\n\n"
    "You will have to ensure that your system has a usable CGAL "
    "installation and re-install deal.II, making sure that cmake "
    "finds the CGAL installation. You can check this by "
    "looking at the summary printed at the end of the cmake "
    "output.");
 
  DeclExceptionMsg(
    ExcNeedsGMSHAPI,
    "You are attempting to use functionality that is only available if deal.II "
    "was configured to use GMSH's API, but cmake did not find a valid GMSH "
    "library."
    "\n\n"
    "You will have to ensure that your system has a usable GMSH "
    "installation (including both the gmsh executable and the GMSH library) "
    "and re-install deal.II, making sure that cmake finds the GMSH "
    "installation. You can check this by looking at the summary printed at the "
    "end of the cmake output.");
 
#ifdef DEAL_II_WITH_MPI
  class ExcMPI : public ::ExceptionBase
  {
  public:
    ExcMPI(const int error_code);
 
    virtual void
    print_info(std::ostream &out) const override;
 
    const int error_code;
  };
#endif // DEAL_II_WITH_MPI
 
 
 
#ifdef DEAL_II_TRILINOS_WITH_SEACAS
  class ExcExodusII : public ExceptionBase
  {
  public:
    ExcExodusII(const int error_code);
 
    virtual void
    print_info(std::ostream &out) const override;
 
    const int error_code;
  };
#endif // DEAL_II_TRILINOS_WITH_SEACAS
 
  DeclExceptionMsg(
    RecoverableUserCallbackError,
    "A user call-back function encountered a recoverable error, "
    "but the underlying library that called the call-back did not "
    "manage to recover from the error and aborted its operation."
    "\n\n"
    "See the glossary entry on user call-back functions for more "
    "information.");
 
} /*namespace StandardExceptions*/
 
 
 
namespace deal_II_exceptions
{
  namespace internals
  {
    extern bool allow_abort_on_exception;
  } // namespace internals
 
  void
  set_additional_assert_output(const char *const p);
 
  void
  suppress_stacktrace_in_exceptions();
 
  void
  disable_abort_on_exception();
 
  void
  enable_abort_on_exception();
 
  namespace internals
  {
    [[noreturn]] void
    abort(const ExceptionBase &exc) noexcept;
 
    enum class ExceptionHandling
    {
      abort_or_throw_on_exception,
      throw_on_exception
    };
 
    template <typename ExceptionType>
    [[noreturn]] void
    issue_error_noreturn(ExceptionHandling handling,
                         const char       *file,
                         int               line,
                         const char       *function,
                         const char       *cond,
                         const char       *exc_name,
                         ExceptionType     e)
    {
      static_assert(std::is_base_of_v<ExceptionBase, ExceptionType>,
                    "The provided exception must inherit from ExceptionBase.");
      // Fill the fields of the exception object
      e.set_fields(file, line, function, cond, exc_name);
 
      switch (handling)
        {
          case ExceptionHandling::abort_or_throw_on_exception:
            {
              if (::deal_II_exceptions::internals::
                    allow_abort_on_exception)
                internals::abort(e);
              else
                {
                  // We are not allowed to abort, so just throw the error:
                  throw e;
                }
            }
          case ExceptionHandling::throw_on_exception:
            throw e;
          // this function should never return (and AssertNothrow can);
          // something must have gone wrong in the error handling code for us
          // to get this far, so throw an exception.
          default:
            throw ::StandardExceptions::ExcInternalError();
        }
    }
 
    [[noreturn]] DEAL_II_HOST_DEVICE inline void
    do_unreachable(const char *file,
                   int         line,
                   const char *function,
                   const char *msg)
    {
#if DEAL_II_KOKKOS_VERSION_GTE(3, 6, 0)
      (void)file;
      (void)line;
      (void)function;
      KOKKOS_IF_ON_DEVICE(({ Kokkos::abort(msg); }))
      KOKKOS_IF_ON_HOST(({
        issue_error_noreturn(::deal_II_exceptions::internals::
                               ExceptionHandling::abort_or_throw_on_exception,
                             file,
                             line,
                             function,
                             nullptr,
                             nullptr,
                             ::StandardExceptions::ExcMessage(msg));
      }))
#else
      // KOKKOS_IF_ON_DEVICE is only supported in 3.6 or newer. We require 3.7
      // on device though, so this means we won't be on device here:
      issue_error_noreturn(::deal_II_exceptions::internals::
                             ExceptionHandling::abort_or_throw_on_exception,
                           file,
                           line,
                           function,
                           nullptr,
                           nullptr,
                           ::StandardExceptions::ExcMessage(msg));
#endif
      // This workaround is necessary, otherwise nvcc will complain that we
      // might return from this function, even though we will never get here (we
      // will throw or abort above).
      while (true)
        {
        }
    }
 
 
 
    [[noreturn]] DEAL_II_HOST_DEVICE inline void
    do_not_implemented(const char *file, int line, const char *function)
    {
#if DEAL_II_KOKKOS_VERSION_GTE(3, 6, 0)
      (void)file;
      (void)line;
      (void)function;
      KOKKOS_IF_ON_DEVICE(
        ({ Kokkos::abort("DEAL_II_NOT_IMPLEMENTED reached."); }))
      KOKKOS_IF_ON_HOST(({
        issue_error_noreturn(::deal_II_exceptions::internals::
                               ExceptionHandling::abort_or_throw_on_exception,
                             file,
                             line,
                             function,
                             nullptr,
                             nullptr,
                             ::StandardExceptions::ExcNotImplemented());
      }))
#else
      // KOKKOS_IF_ON_DEVICE is only supported in 3.6 or newer. We require 3.7
      // on device though, so this means we won't be on device here:
      issue_error_noreturn(::deal_II_exceptions::internals::
                             ExceptionHandling::abort_or_throw_on_exception,
                           file,
                           line,
                           function,
                           nullptr,
                           nullptr,
                           ::StandardExceptions::ExcNotImplemented());
#endif
      // This workaround is necessary, otherwise nvcc will complain that we
      // might return from this function, even though we will never get here (we
      // will throw or abort above).
      while (true)
        {
        }
    }
 
 
 
    void
    do_issue_error_nothrow(const ExceptionBase &e) noexcept;
 
    template <typename ExceptionType>
    void
    issue_error_nothrow(const char   *file,
                        int           line,
                        const char   *function,
                        const char   *cond,
                        const char   *exc_name,
                        ExceptionType e) noexcept
    {
      static_assert(std::is_base_of_v<ExceptionBase, ExceptionType>,
                    "The provided exception must inherit from ExceptionBase.");
      // Fill the fields of the exception object
      e.set_fields(file, line, function, cond, exc_name);
      // avoid moving a bunch of code into the header by dispatching to
      // another function:
      do_issue_error_nothrow(e);
    }
  } /*namespace internals*/
 
} /*namespace deal_II_exceptions*/
 
 
 
namespace deal_II_exceptions
{
  namespace internals
  {
    template <typename T, typename U>
    inline DEAL_II_HOST_DEVICE constexpr bool
    compare_for_equality(const T t, const U u)
    {
      using common_type = std::common_type_t<T, U>;
      return static_cast<common_type>(t) == static_cast<common_type>(u);
    }
 
 
    template <typename T, typename U>
    inline DEAL_II_HOST_DEVICE constexpr bool
    compare_less_than(const T t, const U u)
    {
      using common_type = std::common_type_t<T, U>;
      return (static_cast<common_type>(t) < static_cast<common_type>(u));
    }
  } // namespace internals
} // namespace deal_II_exceptions
 
 
 
namespace internal
{
  // Workaround to allow for commas in template parameter lists
  // in preprocessor macros as found in
  // https://stackoverflow.com/questions/13842468/comma-in-c-c-macro
  template <typename F>
  struct argument_type;
 
  template <typename T, typename U>
  struct argument_type<T(U)>
  {
    using type = U;
  };
 
  template <typename F>
  using argument_type_t = typename argument_type<F>::type;
} // namespace internal
 
 
using namespace StandardExceptions;
 
DEAL_II_NAMESPACE_CLOSE
 
#endif