lemon/error.h
author Peter Kovacs <kpeter@inf.elte.hu>
Tue, 18 Mar 2008 16:45:21 +0100
changeset 95 cc7e6b8b59bf
child 108 889d0c289d19
permissions -rw-r--r--
Bug fix in arg_parser.h (fix ticket #31) and doc improvements
     1 /* -*- C++ -*-
     2  *
     3  * This file is a part of LEMON, a generic C++ optimization library
     4  *
     5  * Copyright (C) 2003-2008
     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
     8  *
     9  * Permission to use, modify and distribute this software is granted
    10  * provided that this copyright notice appears in all copies. For
    11  * precise terms see the accompanying LICENSE file.
    12  *
    13  * This software is provided "AS IS" with no warranty of any kind,
    14  * express or implied, and with no claim as to its suitability for any
    15  * purpose.
    16  *
    17  */
    18 
    19 #ifndef LEMON_ERROR_H
    20 #define LEMON_ERROR_H
    21 
    22 /// \ingroup exceptions
    23 /// \file
    24 /// \brief Basic exception classes and error handling.
    25 
    26 #include <exception>
    27 #include <string>
    28 #include <sstream>
    29 #include <iostream>
    30 #include <cstdlib>
    31 #include <memory>
    32 
    33 namespace lemon {
    34 
    35   /// \addtogroup exceptions
    36   /// @{
    37 
    38   /// \brief Exception safe wrapper class.
    39   ///
    40   /// Exception safe wrapper class to implement the members of exceptions.
    41   template <typename _Type>
    42   class ExceptionMember {
    43   public:
    44     typedef _Type Type;
    45 
    46     ExceptionMember() throw() {
    47       try {
    48 	ptr.reset(new Type());
    49       } catch (...) {}
    50     }
    51 
    52     ExceptionMember(const Type& type) throw() {
    53       try {
    54 	ptr.reset(new Type());
    55 	if (ptr.get() == 0) return;
    56 	*ptr = type;
    57       } catch (...) {}
    58     }
    59 
    60     ExceptionMember(const ExceptionMember& copy) throw() {
    61       try {
    62 	if (!copy.valid()) return;
    63 	ptr.reset(new Type());
    64 	if (ptr.get() == 0) return;
    65 	*ptr = copy.get();
    66       } catch (...) {}
    67     }
    68 
    69     ExceptionMember& operator=(const ExceptionMember& copy) throw() {
    70       if (ptr.get() == 0) return;
    71       try {
    72 	if (!copy.valid()) return;
    73  	*ptr = copy.get();
    74       } catch (...) {}
    75     }
    76 
    77     void set(const Type& type) throw() {
    78       if (ptr.get() == 0) return;
    79       try {
    80 	*ptr = type;
    81       } catch (...) {}
    82     }
    83 
    84     const Type& get() const {
    85       return *ptr;
    86     }
    87 
    88     bool valid() const throw() {
    89       return ptr.get() != 0;
    90     }
    91 
    92   private:
    93     std::auto_ptr<_Type> ptr;
    94   };
    95 
    96   /// Exception-safe convenient "error message" class.
    97 
    98   /// Helper class which provides a convenient ostream-like (operator <<
    99   /// based) interface to create a string message. Mostly useful in
   100   /// exception classes (therefore the name).
   101   class ErrorMessage {
   102   protected:
   103     ///\e
   104 
   105     ///\todo The good solution is boost::shared_ptr...
   106     ///
   107     mutable std::auto_ptr<std::ostringstream> buf;
   108 
   109     ///\e
   110     bool init() throw() {
   111       try {
   112 	buf.reset(new std::ostringstream);
   113       }
   114       catch(...) {
   115 	buf.reset();
   116       }
   117       return buf.get();
   118     }
   119 
   120   public:
   121 
   122     ///\e
   123     ErrorMessage() throw() { init(); }
   124 
   125     ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
   126 
   127     ///\e
   128     ErrorMessage(const char *msg) throw() {
   129       init();
   130       *this << msg;
   131     }
   132 
   133     ///\e
   134     ErrorMessage(const std::string &msg) throw() {
   135       init();
   136       *this << msg;
   137     }
   138 
   139     ///\e
   140     template <typename T>
   141     ErrorMessage& operator<<(const T &t) throw() {
   142       if( ! buf.get() ) return *this;
   143 
   144       try {
   145 	*buf << t;
   146       }
   147       catch(...) {
   148 	buf.reset();
   149       }
   150       return *this;
   151     }
   152 
   153     ///\e
   154     const char* message() throw() {
   155       if( ! buf.get() ) return 0;
   156 
   157       const char* mes = 0;
   158       try {
   159 	mes = buf->str().c_str();
   160       }
   161       catch(...) {}
   162       return mes;
   163     }
   164 
   165   };
   166 
   167   /// Generic exception class.
   168 
   169   /// Base class for exceptions used in LEMON.
   170   ///
   171   class Exception : public std::exception {
   172   public:
   173     ///\e
   174     Exception() {}
   175     ///\e
   176     virtual ~Exception() throw() {}
   177     ///\e
   178     virtual const char* what() const throw() {
   179       return "lemon::Exception";
   180     }
   181   };
   182 
   183   /// One of the two main subclasses of \ref Exception.
   184 
   185   /// Logic errors represent problems in the internal logic of a program;
   186   /// in theory, these are preventable, and even detectable before the
   187   /// program runs (e.g. violations of class invariants).
   188   ///
   189   /// A typical example for this is \ref UninitializedParameter.
   190   class LogicError : public Exception {
   191   public:
   192     virtual const char* what() const throw() {
   193       return "lemon::LogicError";
   194     }
   195   };
   196 
   197   /// \ref Exception for uninitialized parameters.
   198 
   199   /// This error represents problems in the initialization
   200   /// of the parameters of the algorithms.
   201   class UninitializedParameter : public LogicError {
   202   public:
   203     virtual const char* what() const throw() {
   204       return "lemon::UninitializedParameter";
   205     }
   206   };
   207 
   208 
   209   /// One of the two main subclasses of \ref Exception.
   210 
   211   /// Runtime errors represent problems outside the scope of a program;
   212   /// they cannot be easily predicted and can generally only be caught
   213   /// as the program executes.
   214   class RuntimeError : public Exception {
   215   public:
   216     virtual const char* what() const throw() {
   217       return "lemon::RuntimeError";
   218     }
   219   };
   220 
   221   ///\e
   222   class RangeError : public RuntimeError {
   223   public:
   224     virtual const char* what() const throw() {
   225       return "lemon::RangeError";
   226     }
   227   };
   228 
   229   ///\e
   230   class IoError : public RuntimeError {
   231   public:
   232     virtual const char* what() const throw() {
   233       return "lemon::IoError";
   234     }
   235   };
   236 
   237   ///\e
   238   class DataFormatError : public IoError {
   239   protected:
   240     ExceptionMember<std::string> _message;
   241     ExceptionMember<std::string> _file;
   242     int _line;
   243 
   244     mutable ExceptionMember<std::string> _message_holder;
   245   public:
   246 
   247     DataFormatError(const DataFormatError &dfe) :
   248       IoError(dfe), _message(dfe._message), _file(dfe._file),
   249       _line(dfe._line) {}
   250 
   251     ///\e
   252     explicit DataFormatError(const char *the_message)
   253       : _message(the_message), _line(0) {}
   254 
   255     ///\e
   256     DataFormatError(const std::string &file_name, int line_num,
   257 		    const char *the_message)
   258       : _message(the_message), _line(line_num) { file(file_name); }
   259 
   260     ///\e
   261     void line(int ln) { _line = ln; }
   262     ///\e
   263     void message(const std::string& msg) { _message.set(msg); }
   264     ///\e
   265     void file(const std::string &fl) { _file.set(fl); }
   266 
   267     ///\e
   268     int line() const { return _line; }
   269     ///\e
   270     const char* message() const {
   271       if (_message.valid() && !_message.get().empty()) {
   272 	return _message.get().c_str();
   273       } else {
   274 	return 0;
   275       }
   276     }
   277 
   278     /// \brief Returns the filename.
   279     ///
   280     /// Returns \e null if the filename was not specified.
   281     const char* file() const {
   282       if (_file.valid() && !_file.get().empty()) {
   283 	return _file.get().c_str();
   284       } else {
   285 	return 0;
   286       }
   287     }
   288 
   289     ///\e
   290     virtual const char* what() const throw() {
   291       try {
   292 	std::ostringstream ostr;
   293 	ostr << "lemon:DataFormatError" << ": ";
   294 	if (message()) ostr << message();
   295 	if( file() || line() != 0 ) {
   296 	  ostr << " (";
   297 	  if( file() ) ostr << "in file '" << file() << "'";
   298 	  if( file() && line() != 0 ) ostr << " ";
   299 	  if( line() != 0 ) ostr << "at line " << line();
   300 	  ostr << ")";
   301 	}
   302 	_message_holder.set(ostr.str());
   303       }
   304       catch (...) {}
   305       if( _message_holder.valid()) return _message_holder.get().c_str();
   306       return "lemon:DataFormatError";
   307     }
   308 
   309     virtual ~DataFormatError() throw() {}
   310   };
   311 
   312   ///\e
   313   class FileOpenError : public IoError {
   314   protected:
   315     ExceptionMember<std::string> _file;
   316 
   317     mutable ExceptionMember<std::string> _message_holder;
   318   public:
   319 
   320     FileOpenError(const FileOpenError &foe) :
   321       IoError(foe), _file(foe._file) {}
   322 
   323     ///\e
   324     explicit FileOpenError(const std::string& fl)
   325       : _file(fl) {}
   326 
   327 
   328     ///\e
   329     void file(const std::string &fl) { _file.set(fl); }
   330 
   331     /// \brief Returns the filename.
   332     ///
   333     /// Returns \e null if the filename was not specified.
   334     const char* file() const {
   335       if (_file.valid() && !_file.get().empty()) {
   336 	return _file.get().c_str();
   337       } else {
   338 	return 0;
   339       }
   340     }
   341 
   342     ///\e
   343     virtual const char* what() const throw() {
   344       try {
   345 	std::ostringstream ostr;
   346 	ostr << "lemon::FileOpenError" << ": ";
   347 	ostr << "Cannot open file - " << file();
   348 	_message_holder.set(ostr.str());
   349       }
   350       catch (...) {}
   351       if( _message_holder.valid()) return _message_holder.get().c_str();
   352       return "lemon::FileOpenError";
   353     }
   354     virtual ~FileOpenError() throw() {}
   355   };
   356 
   357   class IoParameterError : public IoError {
   358   protected:
   359     ExceptionMember<std::string> _message;
   360     ExceptionMember<std::string> _file;
   361 
   362     mutable ExceptionMember<std::string> _message_holder;
   363   public:
   364 
   365     IoParameterError(const IoParameterError &ile) :
   366       IoError(ile), _message(ile._message), _file(ile._file) {}
   367 
   368     ///\e
   369     explicit IoParameterError(const char *the_message)
   370       : _message(the_message) {}
   371 
   372     ///\e
   373     IoParameterError(const char *file_name, const char *the_message)
   374       : _message(the_message), _file(file_name) {}
   375 
   376      ///\e
   377     void message(const std::string& msg) { _message.set(msg); }
   378     ///\e
   379     void file(const std::string &fl) { _file.set(fl); }
   380 
   381      ///\e
   382     const char* message() const {
   383       if (_message.valid()) {
   384 	return _message.get().c_str();
   385       } else {
   386 	return 0;
   387       }
   388     }
   389 
   390     /// \brief Returns the filename.
   391     ///
   392     /// Returns \c 0 if the filename was not specified.
   393     const char* file() const {
   394       if (_file.valid()) {
   395 	return _file.get().c_str();
   396       } else {
   397 	return 0;
   398       }
   399     }
   400 
   401     ///\e
   402     virtual const char* what() const throw() {
   403       try {
   404 	std::ostringstream ostr;
   405 	if (message()) ostr << message();
   406 	if (file()) ostr << "(when reading file '" << file() << "')";
   407 	_message_holder.set(ostr.str());
   408       }
   409       catch (...) {}
   410       if( _message_holder.valid() ) return _message_holder.get().c_str();
   411       return "lemon:IoParameterError";
   412     }
   413     virtual ~IoParameterError() throw() {}
   414   };
   415 
   416 
   417   ///\e
   418   class AssertionFailedError : public LogicError {
   419   protected:
   420     const char *assertion;
   421     const char *file;
   422     int line;
   423     const char *function;
   424     const char *message;
   425 
   426     mutable ExceptionMember<std::string> _message_holder;
   427   public:
   428     ///\e
   429     AssertionFailedError(const char *_file, int _line, const char *func,
   430 			 const char *msg, const char *_assertion = 0) :
   431       assertion(_assertion), file(_file), line(_line), function(func),
   432       message(msg) {}
   433 
   434     ///\e
   435     const char* get_assertion() const { return assertion; }
   436     ///\e
   437     const char* get_message() const { return message; }
   438     ///\e
   439     const char* get_file() const { return file; }
   440     ///\e
   441     const char* get_function() const { return function; }
   442     ///\e
   443     int get_line() const { return line; }
   444 
   445 
   446     virtual const char* what() const throw() {
   447       try {
   448 	std::ostringstream ostr;
   449 	ostr << file << ":" << line << ": ";
   450 	if( function )
   451 	  ostr << function << ": ";
   452 	ostr << message;
   453 	if( assertion )
   454 	   ostr << " (assertion '" << assertion << "' failed)";
   455 	_message_holder.set(ostr.str());
   456 	return ostr.str().c_str();
   457       }
   458       catch(...) {}
   459       if( _message_holder.valid() ) return _message_holder.get().c_str();
   460       return "lemon::AssertionFailedError";
   461     }
   462    virtual ~AssertionFailedError() throw() {}
   463   };
   464 
   465 
   466   /****************  Macros  ****************/
   467 
   468 
   469   template <typename Exception>
   470   inline void assert_fail(const char *file, int line,
   471                           const char *func,
   472                           Exception exception,
   473                           const char *assertion = 0,
   474                           bool do_abort=true)
   475   {
   476     using namespace std;
   477     cerr << file << ":" << line << ": ";
   478     if (func)
   479       cerr << func << ": ";
   480     cerr << exception.what();
   481     if (assertion)
   482       cerr << " (assertion '" << assertion << "' failed)";
   483     cerr << endl;
   484     if (do_abort)
   485       abort();
   486   }
   487 
   488   template <>
   489   inline void assert_fail<const char *>(const char *file, int line,
   490                                         const char *func,
   491                                         const char *message,
   492                                         const char *assertion,
   493                                         bool do_abort)
   494   {
   495     using namespace std;
   496     cerr << file << ":" << line << ": ";
   497     if (func)
   498       cerr << func << ": ";
   499     cerr << message;
   500     if (assertion)
   501       cerr << " (assertion '" << assertion << "' failed)";
   502     cerr << endl;
   503     if (do_abort)
   504       abort();
   505   }
   506 
   507   template <>
   508   inline void assert_fail<std::string>(const char *file, int line,
   509                                        const char *func,
   510                                        std::string message,
   511                                        const char *assertion,
   512                                        bool do_abort)
   513   {
   514     assert_fail(file, line, func, message.c_str(), assertion, do_abort);
   515   }
   516 
   517   template <typename Exception>
   518   inline void assert_fail_failure(const char *file, int line, const char *func,
   519 			   Exception exception,
   520 			   const char *assertion = 0,
   521 			   bool = true)
   522   {
   523     throw AssertionFailedError(file, line, func, exception.what(), assertion);
   524   }
   525 
   526   template <>
   527   inline void assert_fail_failure<const char *>(const char *file, int line,
   528                                                 const char *func,
   529                                                 const char *message,
   530                                                 const char *assertion,
   531                                                 bool)
   532   {
   533     throw AssertionFailedError(file, line, func, message, assertion);
   534   }
   535 
   536   template <>
   537   inline void assert_fail_failure<std::string>(const char *file, int line,
   538                                                const char *func,
   539                                                std::string message,
   540                                                const char *assertion,
   541                                                bool)
   542   {
   543     assert_fail_failure(file, line, func, message.c_str(), assertion, true);
   544   }
   545 
   546   template <typename Exception>
   547   inline void assert_fail_exception(const char *file, int line, const char *func,
   548 			     Exception exception,
   549 			     const char *assertion = 0, bool = true)
   550   {
   551     throw exception;
   552   }
   553 
   554   template <>
   555   inline void assert_fail_exception<const char *>(const char *file, int line,
   556 					   const char *func,
   557 					   const char *message,
   558 					   const char *assertion,
   559 					   bool)
   560   {
   561     throw AssertionFailedError(file, line, func, message, assertion);
   562   }
   563 
   564   template <>
   565   inline void assert_fail_exception<std::string>(const char *file, int line,
   566                                                  const char *func,
   567                                                  std::string message,
   568                                                  const char *assertion,
   569                                                  bool)
   570   {
   571     assert_fail_exception(file, line, func, message.c_str(), assertion, true);
   572   }
   573 
   574 /// @}
   575 
   576 }
   577 #endif // LEMON_ERROR_H
   578 
   579 #undef LEMON_ASSERT
   580 #undef LEMON_FIXME
   581 
   582 #ifdef LEMON_ENABLE_ASSERTS
   583 #  define LEMON_ASSERT_ABORT
   584 #endif
   585 
   586 #ifndef LEMON_ASSERT_DO_ABORT
   587 #  define LEMON_ASSERT_DO_ABORT 1
   588 #endif
   589 
   590 #ifndef LEMON_ASSERT_HANDLER
   591 #  if defined LEMON_ASSERT_EXCEPTION
   592 #    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception
   593 #  elif defined LEMON_ASSERT_FAILURE
   594 #    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_failure
   595 #  elif defined LEMON_ASSERT_ABORT
   596 #    define LEMON_ASSERT_HANDLER ::lemon::assert_fail
   597 #  else
   598 #    define LEMON_DISABLE_ASSERTS
   599 #  endif
   600 #endif
   601 
   602 #ifdef DOXYGEN
   603 
   604 /// \brief Macro for assertions with customizable message
   605 ///
   606 /// Macro for assertions with customizable message.
   607 ///
   608 /// The assertions are disabled in the default behaviour. You can
   609 /// enable the assertions with the
   610 /// \code
   611 /// #define LEMON_ENABLE_ASSERTS
   612 /// \endcode
   613 /// Then an assert
   614 /// provides a log on the standard error about the assertion and aborts
   615 /// the program if LEMON_ASSERT_DO_ABORT is also defined (otherwise the
   616 /// program keeps on running).
   617 /// By defining LEMON_ASSERT_FAILURE or
   618 /// LEMON_ASSERT_EXCEPTION, you can set other behaviour to the
   619 /// assertions. In case LEMON_ASSERT_FAILURE is given, LEMON_ASSERT
   620 /// will always throw an \c AssertionFailedError exception with
   621 /// the \c msg error message. By using
   622 /// LEMON_ASSERT_EXCEPTION, one can define an arbitrary exception to be thrown.
   623 ///
   624 /// The LEMON_ASSERT macro should be called with the \c exp parameter
   625 /// which should be an expression convertible to bool. If the given
   626 /// parameter is false the assertion is raised and one of the assertion
   627 /// behaviour will be activated. The \c msg should be either a const
   628 /// char* message or an exception. When the \c msg is an exception the
   629 /// \ref lemon::Exception::what() "what()" function is called to retrieve and
   630 /// display the error message.
   631 ///
   632 /// \todo We should provide some way to reset to the default behaviour,
   633 /// shouldn't we?
   634 ///
   635 /// \todo This whole 'assert' business should be placed in a separate
   636 /// include file. The boost assert is not guarded by header sentries
   637 /// which may help to change the behaviour of the assertions in
   638 /// the files.
   639 ///
   640 /// \todo __PRETTY_FUNCTION__ should be replaced by something
   641 /// compiler-independent, like BOOST_CURRENT_FUNCTION
   642 
   643 #  define LEMON_ASSERT(exp, msg)                 \
   644      (static_cast<void> (!!(exp) ? 0 : (         \
   645        LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
   646                             __PRETTY_FUNCTION__, \
   647                             msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))
   648 
   649 #else
   650 #  if defined LEMON_DISABLE_ASSERTS
   651 
   652 #    define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))
   653 
   654 #  else
   655 #    define LEMON_ASSERT(exp, msg)                 \
   656        (static_cast<void> (!!(exp) ? 0 : (         \
   657          LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
   658                               __PRETTY_FUNCTION__, \
   659                               msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))
   660 #  endif
   661 #endif
   662 
   663 /**
   664  * \brief Macro for mark not yet implemented features.
   665  *
   666  * \todo Is this the right place for this? It should be used only in
   667  * modules under development.
   668  *
   669  * \todo __PRETTY_FUNCTION__ should be replaced by something
   670  * compiler-independent, like BOOST_CURRENT_FUNCTION
   671  */
   672 
   673 #define LEMON_FIXME(msg) \
   674     (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
   675 			  "FIXME: " msg))