lemon-0.x: comparison src/work/klao/error.h

equal deleted inserted replaced

-:93f2408b4f12
+:ceb03fda6d91
 * \brief Generic exception class.
 *
 * Base class for exceptions used in LEMON.
 */
 class Exception : public std::exception {
-protected:
+public:
 ///\e
-const char *message;
+Exception() {}
-public:
-///\e
-Exception() throw() : message(0) {}
-///\e
-explicit Exception(const char *msg) throw()
-: message(msg) {}
 ///\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 exceptionName();
-return "lemon::Exception";
+}
-}
+};
-};
+/**
-///\e
+* \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
+virtual const char* exceptionName() const {
-explicit LogicError() {}
+return "lemon::LogicError";
-///\e
+}
-explicit LogicError(const char *s)
+};
-: Exception(s) {}
-};
+/**
-///\e
+* \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
+virtual const char* exceptionName() const {
-explicit RuntimeError() {}
+return "lemon::RuntimeError";
-///\e
+}
-explicit RuntimeError(const char *s)
-: Exception(s) {}
 };
 ///\e
 class RangeError : public RuntimeError {
 public:
-///\e
+virtual const char* exceptionName() const {
-explicit RangeError(const char *s)
+return "lemon::RangeError";
-: RuntimeError(s) {}
+}
 };
 ///\e
 class IOError : public RuntimeError {
 public:
-///\e
+virtual const char* exceptionName() const {
-explicit IOError(const char *s)
+return "lemon::IOError";
-: RuntimeError(s) {}
+}
 };
 ///\e
 class DataFormatError : public IOError {
 protected:
-int line;
+const char *_message;
-boost::shared_ptr<std::string> file;
+int _line;
+boost::shared_ptr<std::string> _file;
-public:
-///\e
+public:
-explicit DataFormatError(const char *message)
+///\e
-: IOError(message), line(0) {}
+explicit DataFormatError(const char *the_message)
+: _message(the_message), _line(0) {}
 ///\e
 DataFormatError(const std::string &file_name, int line_num,
-		    const char *message)
+		    const char *the_message)
-: IOError(message), line(line_num) { set_file(file_name); }
+: _message(the_message), _line(line_num) { file(file_name); }
 ///\e
-void set_line(int line_num) { line=line_num; }
+void line(int line_num) { _line=line_num; }
 ///\e
-void set_file(const std::string &file_name) {
+void message(char *the_message) { _message=the_message; }
-try {
+///\e
-	file.reset(new std::string);
+void file(const std::string &file_name) {
-	*file = file_name;
+try {
+	_file.reset(new std::string);
+	*_file = file_name;
 }
 catch(...) {
-	file.reset();
+	_file.reset();
 }
 }
 ///\e
-int get_line() const { return line; }
+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 {
+const char* file() const {
-if( file )
+if( _file )
-	return file->c_str();
+	return _file->c_str();
 else
 	return "(unknown)";
 }
 ///\e
 virtual const char* what() const throw() {
 const char *mes = 0;
 try {
 	std::ostringstream ostr;
-	ostr << IOError::what();
+	ostr << _message;
-	if( file || line ) {
+	if( _file || _line ) {
 	  ostr << " (";
-	  if( file ) ostr << "in file '" << *file << "'";
+	  if( _file ) ostr << "in file '" << *_file << "'";
-	  if( file && line ) ostr << " ";
+	  if( _file && _line ) ostr << " ";
-	  if( line ) ostr << "at line " << line;
+	  if( _line ) ostr << "at line " << _line;
 	  ostr << ")";
 	}
 	mes = ostr.str().c_str();
 }
 catch(...) {}
 if( mes ) return mes;
+return exceptionName();
+}
+virtual const char* exceptionName() const {
 return "lemon::DataFormatError";
 }
 virtual ~DataFormatError() throw() {}
 };
 	  ostr << " (assertion '" << assertion << "' failed)";
 	mes = ostr.str().c_str();
 }
 catch(...) {}
 if( mes ) return mes;
+return exceptionName();
+}
+virtual const char* exceptionName() const {
 return "lemon::AssertionFailedError";
 }
 virtual ~AssertionFailedError() throw() {}
 };
 #ifndef LEMON_ASSERT_ABORT
 #  define LEMON_ASSERT_ABORT 1
 #endif
 #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
 #if defined(NDEBUG) || defined(LEMON_DISABLE_ASSERTS)
 #  define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))
 #else
 /**
 * \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
 * compiler-independant, like BOOST_CURRENT_FUNCTION
 */
 (static_cast<void> (!!(exp) ? 0 : (         \
 LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
 __PRETTY_FUNCTION__, \
 			    (msg), #exp, LEMON_ASSERT_ABORT), 0)))
-# endif // NDEBUG
+#endif // NDEBUG || LEMON_DISABLE_ASSERTS
 /**
 * \brief Macro for mark not yet implemented features.
 *
 * \todo Is this the right place for this? It should be used only in

changeset 1120	5d8d64bde9c5
parent 1068	e0b0dcee5e17