Changeset 1056:cbc27743e17a in lemon-0.x for src/work/klao

Timestamp:

01/07/05 01:43:54 (19 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1452

Message:

Exception hierarchy sketch.
Exception safe exception classes.

File:

• src/work/klao/error.h (copied) (copied from src/lemon/error.h) (2 diffs)

src/work/klao/error.h

@@ -26 +26 @@
 #include <sstream>
 
+#include <boost/shared_ptr.hpp>
 
 namespace lemon {
+
+  /// Exception-safe convenient "error message" class.
+  class ErrorMessage {
+  protected:
+    boost::shared_ptr<std::ostringstream> buf;
+    
+    bool init() throw() {
+      try {
+        buf.reset(new std::ostringstream);
+      }
+      catch(...) {
+        buf.reset();
+      }
+      return buf;
+    }
+
+  public:
+
+    ErrorMessage() throw() { init(); }
+
+    ErrorMessage(const char *message) throw() {
+      init();
+      *this << message;
+    }
+
+    ErrorMessage(const std::string &message) throw() {
+      init();
+      *this << message;
+    }
+
+    template <typename T>
+    ErrorMessage& operator<<(const T &t) throw() {
+      if( !buf ) return *this;
+
+      try {
+        *buf << t;
+      }
+      catch(...) {
+        buf.reset();
+      }
+    }
+
+    const char* message() throw() {
+      if( !buf ) return 0;
+
+      const char* mes = 0;
+      try {
+        mes = buf->str().c_str();
+      }
+      catch(...) {}
+      return mes;
+    }
+    
+  };
 
   /**
    * \brief Generic exception class.
    *
-   * \todo Do we need this?
-   *
-   * \todo Don't we need different kind of exceptions for different kind
-   * of errors?
-   * Shouldn't we use \<stdexcept\> instead?
+   * Base class for exceptions used in LEMON.
    */
-  class Exception : public std::exception {
-  protected:
-    std::ostringstream buf;
+  class Exception : public std::exception, public ErrorMessage {
   public:
-    Exception() {}
-    explicit Exception(const std::string &s) { buf << s; }
-    Exception(const Exception &e) : std::exception() {
-      buf << e.buf.str();
-    }
+    Exception() throw() {}
+    explicit Exception(const std::string &s) throw()
+      : ErrorMessage(s) {}
     virtual ~Exception() throw() {}
     
     virtual const char* what() const throw() {
-      return buf.str().c_str();
+      const char *mes = message();
+      if( mes ) return mes;
+      return "lemon::Exception";
+    }
+  };
+
+
+  class LogicError : public Exception {
+    explicit LogicError(const std::string &s)
+      : Exception(s) {}
+  };
+
+  class RuntimeError : public Exception {
+    explicit RuntimeError(const std::string &s)
+      : Exception(s) {}
+  };
+
+  class RangeError : public RuntimeError {
+    explicit RangeError(const std::string &s)
+      : RuntimeError(s) {}
+  };
+
+  class IOError : public RuntimeError {
+    explicit IOError(const std::string &s)
+      : RuntimeError(s) {}
+  };
+
+  class DataFormatError : public IOError {
+    explicit DataFormatError(const std::string &message)
+      : IOError(message) : line(0) {}
+    DataFormatError(const std::string &file_name, int line_num,
+                    sconst std::string &message)
+      : IOError(message), line(line_num) { set_file(file_name); }
+
+    void set_line(int line_num) { line=line_num; }
+    void set_file(const std::string &file_name) {
+      try {
+        file.reset(new std::string);
+        *file = file_name;
+      }
+      catch(...) {
+        file.reset();
+      }
     }
 
-    template <typename T>
-    Exception& operator<<(T const& t) { buf << t; return *this; }
+    virtual const char* what() const {
+      const char *mes = 0;
+      try {
+        std::ostringstream ostr;
+        ostr << IOError::what();
+        if( file || line ) {
+          ostr << " (";
+          if( file ) ostr << "in file" << *file;
+          if( line ) ostr << " at line" << line;
+        }
+        mes = ostr.str().c_str();
+      }
+      catch(...) {}
+      if( mes ) return mes;
+      return "lemon::DataFormatError";
+    }
   };
 
+
+
+  /****************  Macros  ****************/
+
+
   /**
-   * \brief Generic error signaling function.
-   *
-   * \todo Do we really need this? Is it helpful?
+   * \brief Macro for assertions with customizable message
    */
-  inline void fault(const std::string &msg) {
-    throw Exception(msg);
-  }
+
+# define lemon_assert(exp, msg) \
+    if(!(exp)) { \
+      std::cerr << __FILE__ ":" << __LINE__ << ": " << (msg) << std::endl; \
+      abort; \
+    }
+
 
   /**
@@ -73 +183 @@
    */
 
-# define FIXME(msg) \
-    do { throw ::lemon::Exception() << "FIXME: " msg " (in: "    \
-      __FILE__ ", " << __LINE__ << ")";                          \
-    } while(false)
+# define FIXME(msg) lemon_assert(0, "FIXME: " msg)
 
 }