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:
// $Id$
 
#ifndef DUNE_EXCEPTIONS_HH
#define DUNE_EXCEPTIONS_HH
 
#include <string>
#include <sstream>
 
namespace Dune {
 
  /* forward declarations */
  class Exception;
  struct ExceptionHook;
 
  class Exception {
  public:
    Exception ();
    void message(const std::string &msg); 
    const std::string& what() const;        
    static void registerHook (ExceptionHook * hook); 
    static void clearHook ();                       
  private:
    std::string _message;
    static ExceptionHook * _hook;
  };
 
  struct ExceptionHook
  {
    virtual ~ExceptionHook() {}
    virtual void operator () () = 0;
  };
 
  /*
     Implementation of Dune::Exception
   */
 
  inline Exception::Exception ()
  {
    // call the hook if necessary
    if (_hook != 0) _hook->operator()();
  }
 
  inline void Exception::registerHook (ExceptionHook * hook)
  {
    _hook = hook;
  }
 
  inline void Exception::clearHook ()
  {
    _hook = 0;
  }
 
  inline void Exception::message(const std::string & msg)
  {
    _message = msg;
  }
 
  inline const std::string& Exception::what() const
  {
    return _message;
  }
 
  inline std::ostream& operator<<(std::ostream &stream, const Exception &e)
  {
    return stream << e.what();
  }
 
#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
 
  // this is the magic: use the usual do { ... } while (0) trick, create
  // the full message via a string stream and throw the created object
#define DUNE_THROW(E, m) do { E th__ex; std::ostringstream th__out; \
                              th__out << THROWSPEC(E) << m; th__ex.message(th__out.str()); throw th__ex; \
} while (0)
 
  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