Changeset 1120:5d8d64bde9c5 in lemon-0.x for src

Timestamp:

02/03/05 20:24:42 (19 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

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

Message:

Latest LEMON exception and assert concepts

Location:

src/work/klao

Files:

• error.h (modified) (10 diffs)
• error_test.cc (modified) (5 diffs)

src/work/klao/error.h

@@ -103 +103 @@
    */
   class Exception : public std::exception {
-  protected:
-    ///\e
-    const char *message;
-
-  public:
-    ///\e 
-    Exception() throw() : message(0) {}
-    ///\e 
-    explicit Exception(const char *msg) throw()
-      : message(msg) {}
+  public:
+    ///\e 
+    Exception() {}
     ///\e 
     virtual ~Exception() throw() {}
+
+    ///\e
+    virtual const char* exceptionName() const {
+      return "lemon::Exception";
+    }
     
     ///\e 
     virtual const char* what() const throw() {
-      if( message ) return message;
-      return "lemon::Exception";
-    }
-  };
-
-  ///\e 
+      return exceptionName();
+    }
+  };
+
+  /**
+   * \brief One of the two main subclasses of \ref Exception.
+   *
+   * Logic errors represent problems in the internal logic of a program;
+   * in theory, these are preventable, and even detectable before the
+   * program runs (e.g., violations of class invariants).
+   *
+   * For a typical example \see UninitializedParameterError.
+   */
   class LogicError : public Exception {
   public:
-    ///\e 
-    explicit LogicError() {}
-    ///\e 
-    explicit LogicError(const char *s)
-      : Exception(s) {}
-  };
-
-  ///\e 
+    virtual const char* exceptionName() const {
+      return "lemon::LogicError";
+    }
+  };
+
+  
+  /**
+   * \brief One of the two main subclasses of \ref Exception.
+   *
+   * Runtime errors represent problems outside the scope of a program;
+   * they cannot be easily predicted and can generally only be caught as
+   * the program executes.
+   */
   class RuntimeError : public Exception {
   public:
-    ///\e
-    explicit RuntimeError() {}
-    ///\e
-    explicit RuntimeError(const char *s)
-      : Exception(s) {}
+    virtual const char* exceptionName() const {
+      return "lemon::RuntimeError";
+    }
   };
 
@@ -146 +154 @@
   class RangeError : public RuntimeError {
   public:
-    ///\e 
-    explicit RangeError(const char *s)
-      : RuntimeError(s) {}
+    virtual const char* exceptionName() const {
+      return "lemon::RangeError";
+    }
   };
 
@@ -154 +162 @@
   class IOError : public RuntimeError {
   public:
-    ///\e 
-    explicit IOError(const char *s)
-      : RuntimeError(s) {}
+    virtual const char* exceptionName() const {
+      return "lemon::IOError";
+    }
   };
 
@@ -162 +170 @@
   class DataFormatError : public IOError {
   protected:
-    int line;
-    boost::shared_ptr<std::string> file;
-
-  public:
-    ///\e 
-    explicit DataFormatError(const char *message)
-      : IOError(message), line(0) {}
+    const char *_message;
+    int _line;
+    boost::shared_ptr<std::string> _file;
+
+  public:
+    ///\e 
+    explicit DataFormatError(const char *the_message)
+      : _message(the_message), _line(0) {}
     ///\e 
     DataFormatError(const std::string &file_name, int line_num,
-                    const char *message)
-      : IOError(message), line(line_num) { set_file(file_name); }
-
-    ///\e 
-    void set_line(int line_num) { line=line_num; }
-    ///\e 
-    void set_file(const std::string &file_name) {
-      try {
-        file.reset(new std::string);
-        *file = file_name;
+                    const char *the_message)
+      : _message(the_message), _line(line_num) { file(file_name); }
+
+    ///\e 
+    void line(int line_num) { _line=line_num; }
+    ///\e 
+    void message(char *the_message) { _message=the_message; }
+    ///\e 
+    void file(const std::string &file_name) {
+      try {
+        _file.reset(new std::string);
+        *_file = file_name;
       }
       catch(...) {
-        file.reset();
-      }
-    }
-
-    ///\e
-    int get_line() const { return line; }
+        _file.reset();
+      }
+    }
+
+    ///\e
+    int line() const { return _line; }
+    ///\e
+    const char* message() const { return _message; }
 
     /// \brief Returns the filename.
     ///
     /// Returns \e "(unknown)" if the filename was not specified.
-    const char* get_file() const {
-      if( file )
-        return file->c_str();
+    const char* file() const {
+      if( _file )
+        return _file->c_str();
       else
         return "(unknown)";
@@ -205 +218 @@
       try {
         std::ostringstream ostr;
-        ostr << IOError::what();
-        if( file || line ) {
+        ostr << _message;
+        if( _file || _line ) {
           ostr << " (";
-          if( file ) ostr << "in file '" << *file << "'";
-          if( file && line ) ostr << " ";
-          if( line ) ostr << "at line " << line;
+          if( _file ) ostr << "in file '" << *_file << "'";
+          if( _file && _line ) ostr << " ";
+          if( _line ) ostr << "at line " << _line;
           ostr << ")";
         }
@@ -217 +230 @@
       catch(...) {}
       if( mes ) return mes;
+      return exceptionName();
+    }
+
+    virtual const char* exceptionName() const {
       return "lemon::DataFormatError";
     }
@@ -265 +282 @@
       catch(...) {}
       if( mes ) return mes;
+      return exceptionName();
+    }
+
+    virtual const char* exceptionName() const {
       return "lemon::AssertionFailedError";
     }
@@ -312 +333 @@
 
 #ifndef LEMON_ASSERT_HANDLER
-#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail
+#  ifdef LEMON_ASSERT_EXCEPTION
+#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_throw
+#  else
+#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail
+#  endif
 #endif
 
@@ -323 +348 @@
 /**
  * \brief Macro for assertions with customizable message
+ *
+ * Macro for assertions with customizable message.
+ *
+ * The behaviour can be customized with LEMON_ASSERT_HANDLER,
+ * LEMON_ASSERT_EXCEPTION and LEMON_ASSERT_ABORT defines. Asserts can be
+ * disabled by defining either NDEBUG or LEMON_DISABLE_ASSERTS macros.
+ *
+ * \todo We should provide some way to reset to the default behaviour,
+ * shouldn't we?
+ *
+ * \todo This whole 'assert' business should be placed in a separate
+ * include file.
  *
  * \todo __PRETTY_FUNCTION__ should be replaced by something
@@ -334 +371 @@
                             (msg), #exp, LEMON_ASSERT_ABORT), 0)))
 
-# endif // NDEBUG
+#endif // NDEBUG || LEMON_DISABLE_ASSERTS
 
 /**

src/work/klao/error_test.cc

@@ -16 +16 @@
   }
   catch(lemon::DataFormatError &e) {
-    e.set_file(fn);
-    e.set_line(5);
+    e.file(fn);
+    e.line(5);
     throw;
   }
@@ -28 +28 @@
     parse_file("input.txt");
   }
+  catch(lemon::Exception &e) {
+    cerr << "Exception '" << e.exceptionName()
+         << "' caught: " << endl;
+    cerr << e.what() << endl;
+  }
   catch(exception &e) {
     cerr << "Exception caught: " << endl;
@@ -34 +39 @@
 
   try {
+    throw lemon::LogicError();
+  }
+  catch(lemon::Exception &e) {
+    cerr << "Exception '" << e.exceptionName()
+         << "' caught: " << endl;
+    cerr << e.what() << endl;
+  }
+
+  try {
     fail_assert();
+  }
+  catch(lemon::Exception &e) {
+    cerr << "Exception '" << e.exceptionName()
+         << "' caught: " << endl;
+    cerr << e.what() << endl;
   }
   catch(exception &e) {
@@ -40 +59 @@
     cerr << e.what() << endl;
   }
+
+  cerr << endl;
 
   // assert(1==0);
@@ -47 +68 @@
 
 #undef LEMON_ASSERT_HANDLER
-#define LEMON_ASSERT_HANDLER ::lemon::assert_fail_throw
+#define LEMON_ASSERT_EXCEPTION
 
 #include <error.h>