exceptions.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
 
#ifndef DUNE_EXCEPTIONS_HH
#define DUNE_EXCEPTIONS_HH
 
#include <exception>
#include <string>
#include <sstream>
#include <type_traits>
#include <utility>
 
namespace Dune {
 
  /* forward declarations */
  class Exception;
  struct ExceptionHook;
 
  class Exception
  : public std::exception
  {
  public:
    Exception ();
    void message(const std::string &msg); 
    const char* what() const noexcept override; 
    static void registerHook (ExceptionHook * hook); 
    static void clearHook ();                  
  private:
    std::string _message;
    static ExceptionHook * _hook;
  };
 
  struct ExceptionHook
  {
    virtual ~ExceptionHook() {}
    virtual void operator () () = 0;
  };
 
  inline std::ostream& operator<<(std::ostream &stream, const Exception &e)
  {
    return stream << e.what();
  }
 
 
  template<class E>
  class ExceptionStream
    : public E
  {
  public:
    using E::E;
 
    ExceptionStream(const E& other) :
      E(other)
    {}
 
    ExceptionStream(E&& other) :
      E(std::move(other))
    {}
 
    template<class T>
      requires
        (requires(std::ostringstream& oss, T t) { oss << t; }
        and not std::is_integral_v<T>)
    friend ExceptionStream& operator<<(ExceptionStream& es, const T& t)
    {
      es.sstream_ << t;
      es.message(es.sstream_.str());
      return es;
    }
 
    template<class T>
      requires
        (requires(std::ostringstream& oss, T t) { oss << t; }
        and not std::is_integral_v<T>)
    friend ExceptionStream operator<<(ExceptionStream&& es, const T& t)
    {
      es << t;
      return std::move(es);
    }
 
    template<class T>
      requires std::is_integral_v<T>
    friend ExceptionStream& operator<<(ExceptionStream& es, T t)
    {
      es.sstream_ << t;
      es.message(es.sstream_.str());
      return es;
    }
 
    template<class T>
      requires std::is_integral_v<T>
    friend ExceptionStream operator<<(ExceptionStream&& es, T t)
    {
      es << t;
      return std::move(es);
    }
 
    friend ExceptionStream& operator<<(ExceptionStream& es, std::ostream& (*t)(std::ostream&))
    {
      es.sstream_ << t;
      es.message(es.sstream_.str());
      return es;
    }
 
    friend ExceptionStream operator<<(ExceptionStream&& es, std::ostream& (*t)(std::ostream&))
    {
      es << t;
      return std::move(es);
    }
 
  private:
    std::ostringstream sstream_;
  };
 
 
 
#ifndef DOXYGEN
  // the "format" the exception-type gets printed.  __FILE__ and
  // __LINE__ are standard C-defines, the GNU cpp-infofile claims that
  // C99 defines __func__ as well. __FUNCTION__ is a GNU-extension
#define THROWSPEC(E) # E << " [" << __func__ << ":" << __FILE__ << ":" << __LINE__ << "]: "
#endif // DOXYGEN
 
#define DUNE_THROW(E, ...) throw Dune::ExceptionStream(E()) << THROWSPEC(E) __VA_OPT__(<<) __VA_ARGS__
 
  class IOError : public Exception {};
 
  class MathError : public Exception {};
 
  class RangeError : public Exception {};
 
  class NotImplemented : public Exception {};
 
  class SystemError : public Exception {};
 
  class OutOfMemoryError : public SystemError {};
 
  class InvalidStateException : public Exception {};
 
  class ParallelError : public Exception {};
 
} // end namespace
 
#endif