COIN-OR::LEMON - Graph Library

source: lemon-0.x/src/lemon/error.h @ 1393:2edd8cd06eaf

Last change on this file since 1393:2edd8cd06eaf was 1393:2edd8cd06eaf, checked in by Balazs Dezso, 19 years ago

Bug fix.

File size: 12.6 KB
RevLine 
[906]1/* -*- C++ -*-
[1157]2 *
[921]3 * src/lemon/error.h - Part of LEMON, a generic C++ optimization library
[906]4 *
[1164]5 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi
[1359]6 * Kutatocsoport (Egervary Research Group on Combinatorial Optimization,
[1157]7 * EGRES).
[906]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 */
[883]18
[921]19#ifndef LEMON_ERROR_H
20#define LEMON_ERROR_H
[883]21
[1151]22//! \ingroup exceptions
[883]23//! \file
[1067]24//! \brief Basic exception classes and error handling.
[883]25
26#include <exception>
27#include <string>
28#include <sstream>
[1067]29#include <iostream>
30#include <cstdlib>
[1157]31#include <memory>
[883]32
[921]33namespace lemon {
[883]34
[1207]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) {
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) {
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 {
89      return ptr.get() != 0;
90    }
91   
92  private:
93    std::auto_ptr<_Type> ptr;
94  };
[1151]95
[1056]96  /// Exception-safe convenient "error message" class.
[1067]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).
[1056]101  class ErrorMessage {
102  protected:
[1067]103    ///\e
[1157]104    ///\todo The good solution is boost:shared_ptr...
105    mutable
106    std::auto_ptr<std::ostringstream> buf;
[1056]107   
[1067]108    ///\e
[1056]109    bool init() throw() {
110      try {
111        buf.reset(new std::ostringstream);
112      }
113      catch(...) {
114        buf.reset();
115      }
[1157]116      return buf.get();
[1056]117    }
118
119  public:
120
[1067]121    ///\e
[1056]122    ErrorMessage() throw() { init(); }
123
[1157]124    ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
125
[1067]126    ///\e
[1056]127    ErrorMessage(const char *message) throw() {
128      init();
129      *this << message;
130    }
131
[1067]132    ///\e
[1056]133    ErrorMessage(const std::string &message) throw() {
134      init();
135      *this << message;
136    }
137
[1067]138    ///\e
[1056]139    template <typename T>
140    ErrorMessage& operator<<(const T &t) throw() {
[1157]141      if( ! buf.get() ) return *this;
[1056]142
143      try {
144        *buf << t;
145      }
146      catch(...) {
147        buf.reset();
148      }
[1207]149      return *this;
[1056]150    }
151
[1067]152    ///\e
[1056]153    const char* message() throw() {
[1157]154      if( ! buf.get() ) return 0;
[1056]155
156      const char* mes = 0;
157      try {
158        mes = buf->str().c_str();
159      }
160      catch(...) {}
161      return mes;
162    }
163   
164  };
165
[883]166  /**
167   * \brief Generic exception class.
168   *
[1056]169   * Base class for exceptions used in LEMON.
[883]170   */
[1067]171  class Exception : public std::exception {
[883]172  public:
[1067]173    ///\e
[1120]174    Exception() {}
[1067]175    ///\e
[883]176    virtual ~Exception() throw() {}
[1120]177
178    ///\e
179    virtual const char* exceptionName() const {
180      return "lemon::Exception";
181    }
[883]182   
[1067]183    ///\e
[883]184    virtual const char* what() const throw() {
[1120]185      return exceptionName();
[1056]186    }
187  };
188
[1120]189  /**
190   * \brief One of the two main subclasses of \ref Exception.
191   *
192   * Logic errors represent problems in the internal logic of a program;
193   * in theory, these are preventable, and even detectable before the
194   * program runs (e.g., violations of class invariants).
195   *
[1125]196   * A typical example for this is \ref UninitializedParameter.
[1120]197   */
[1056]198  class LogicError : public Exception {
[1067]199  public:
[1120]200    virtual const char* exceptionName() const {
201      return "lemon::LogicError";
202    }
[1056]203  };
204
[1125]205  /**
206   * \brief \ref Exception for uninitialized parameters.
207   *
208   * This error represents problems in the initialization
209   * of the parameters of the algorithms.
210   */
211  class UninitializedParameter : public LogicError {
212  public:
213    virtual const char* exceptionName() const {
214      return "lemon::UninitializedParameter";
215    }
216  };
217
[1120]218 
219  /**
220   * \brief One of the two main subclasses of \ref Exception.
221   *
222   * Runtime errors represent problems outside the scope of a program;
223   * they cannot be easily predicted and can generally only be caught as
224   * the program executes.
225   */
[1056]226  class RuntimeError : public Exception {
[1067]227  public:
[1120]228    virtual const char* exceptionName() const {
229      return "lemon::RuntimeError";
230    }
[1056]231  };
232
[1067]233  ///\e
[1056]234  class RangeError : public RuntimeError {
[1067]235  public:
[1120]236    virtual const char* exceptionName() const {
237      return "lemon::RangeError";
238    }
[1056]239  };
240
[1061]241  ///\e
[1056]242  class IOError : public RuntimeError {
[1067]243  public:
[1120]244    virtual const char* exceptionName() const {
245      return "lemon::IOError";
246    }
[1056]247  };
248
[1061]249  ///\e
[1056]250  class DataFormatError : public IOError {
[1067]251  protected:
[1207]252    ExceptionMember<std::string> _message;
253    ExceptionMember<std::string> _file;
[1120]254    int _line;
[1157]255
[1207]256    mutable ExceptionMember<std::string> _message_holder;
[1067]257  public:
[1157]258
259    DataFormatError(const DataFormatError &dfe) :
[1207]260      IOError(dfe), _message(dfe._message), _file(dfe._file),
261      _line(dfe._line) {}
[1157]262
[1067]263    ///\e
[1120]264    explicit DataFormatError(const char *the_message)
265      : _message(the_message), _line(0) {}
[1207]266
[1067]267    ///\e
[1056]268    DataFormatError(const std::string &file_name, int line_num,
[1120]269                    const char *the_message)
270      : _message(the_message), _line(line_num) { file(file_name); }
[1056]271
[1067]272    ///\e
[1207]273    void line(int line) { _line = line; }
[1067]274    ///\e
[1207]275    void message(const std::string& message) { _message.set(message); }
[1120]276    ///\e
[1207]277    void file(const std::string &file) { _file.set(file); }
278 
279    ///\e
280    int line() const { return _line; }
281    ///\e
282    const char* message() const {
283      if (_message.valid() && !_message.get().empty()) {
284        return _message.get().c_str();
285      } else {
286        return 0;
[1056]287      }
[883]288    }
289
[1067]290    /// \brief Returns the filename.
291    ///
[1207]292    /// Returns \e null if the filename was not specified.
[1120]293    const char* file() const {
[1207]294      if (_file.valid() && !_file.get().empty()) {
295        return _file.get().c_str();
296      } else {
297        return 0;
298      }
[1067]299    }
300
301    ///\e
302    virtual const char* what() const throw() {
[1056]303      try {
304        std::ostringstream ostr;
[1207]305        if (message()) ostr << message();
306        if( file() || line() != 0 ) {
[1056]307          ostr << " (";
[1207]308          if( file() ) ostr << "in file '" << file() << "'";
309          if( file() && line() != 0 ) ostr << " ";
310          if( line() != 0 ) ostr << "at line " << line();
[1067]311          ostr << ")";
[1056]312        }
[1207]313        _message_holder.set(ostr.str());
[1056]314      }
[1207]315      catch (...) {}
316      if( _message_holder.valid()) return _message_holder.get().c_str();
[1120]317      return exceptionName();
318    }
319
320    virtual const char* exceptionName() const {
[1056]321      return "lemon::DataFormatError";
322    }
[1067]323
324    virtual ~DataFormatError() throw() {}
[883]325  };
326
[1213]327  class IOParameterError : public LogicError {
[1207]328  protected:
329    ExceptionMember<std::string> _message;
330    ExceptionMember<std::string> _file;
331
332    mutable ExceptionMember<std::string> _message_holder;
333  public:
334
[1213]335    IOParameterError(const IOParameterError &ile) :
336      LogicError(ile), _message(ile._message), _file(ile._file) {}
[1207]337
338    ///\e
[1213]339    explicit IOParameterError(const char *the_message)
340      : _message(the_message) {}
[1207]341
342    ///\e
[1213]343    IOParameterError(const char *file_name, const char *the_message)
[1393]344      : _message(the_message), _file(file_name) {}
[1207]345
346     ///\e
347    void message(const std::string& message) { _message.set(message); }
348    ///\e
349    void file(const std::string &file) { _file.set(file); }
350 
351     ///\e
352    const char* message() const {
353      if (_message.valid()) {
354        return _message.get().c_str();
355      } else {
356        return 0;
357      }
358    }
359
360    /// \brief Returns the filename.
361    ///
362    /// Returns \e null if the filename was not specified.
363    const char* file() const {
364      if (_file.valid()) {
365        return _file.get().c_str();
366      } else {
367        return 0;
368      }
369    }
370
371    ///\e
372    virtual const char* what() const throw() {
373      try {
374        std::ostringstream ostr;
375        if (message()) ostr << message();
376        if (file()) ostr << "(when reading file '" << file() << "')";
377        _message_holder.set(ostr.str());
378      }
379      catch (...) {}
380      if( _message_holder.valid() ) return _message_holder.get().c_str();
381      return exceptionName();
382    }
383
384    virtual const char* exceptionName() const {
[1213]385      return "lemon::IOParameterError";
[1207]386    }
387
[1213]388    virtual ~IOParameterError() throw() {}
[1207]389  };
390
[1056]391
[1068]392  ///\e
[1067]393  class AssertionFailedError : public LogicError {
394  protected:
395    const char *assertion;
396    const char *file;
397    int line;
398    const char *function;
399    const char *message;
[1213]400
401    mutable ExceptionMember<std::string> _message_holder;
[1067]402  public:
403    ///\e
404    AssertionFailedError(const char *_file, int _line, const char *func,
405                         const char *msg, const char *_assertion = 0) :
406      assertion(_assertion), file(_file), line(_line), function(func),
407      message(msg) {}
408
409    ///\e
410    const char* get_assertion() const { return assertion; }
411    ///\e
412    const char* get_message() const { return message; }
413    ///\e
414    const char* get_file() const { return file; }
415    ///\e
416    const char* get_function() const { return function; }
417    ///\e
418    int get_line() const { return line; }
419
420
421    virtual const char* what() const throw() {
422      try {
423        std::ostringstream ostr;
424        ostr << file << ":" << line << ": ";
425        if( function )
426          ostr << function << ": ";
427        ostr << message;
428        if( assertion )
[1213]429           ostr << " (assertion '" << assertion << "' failed)";
430        _message_holder.set(ostr.str());
[1209]431        return ostr.str().c_str();
[1067]432      }
433      catch(...) {}
[1213]434      if( _message_holder.valid() ) return _message_holder.get().c_str();
[1120]435      return exceptionName();
436    }
437
438    virtual const char* exceptionName() const {
[1067]439      return "lemon::AssertionFailedError";
440    }
441
442    virtual ~AssertionFailedError() throw() {}
443  };
444
[1056]445
446  /****************  Macros  ****************/
447
448
[1067]449  inline
450  void assert_fail(const char *file, int line, const char *func,
451                   const char *message, const char *assertion = 0,
452                   bool do_abort=true)
453  {
454    using namespace std;
455    cerr << file << ":" << line << ": ";
456    if( func )
457      cerr << func << ": ";
458    cerr << message;
459    if( assertion )
460      cerr << " (assertion '" << assertion << "' failed)";
461    cerr << endl;
462    if(do_abort)
463      abort();
464  }
[1056]465
[1067]466  inline
467  void assert_fail_throw(const char *file, int line, const char *func,
468                   const char *message, const char *assertion = 0,
469                   bool = true)
470  {
471    throw AssertionFailedError(file, line, func, message, assertion);
472  }
[1056]473
[1151]474/// @}
[883]475
476}
[921]477#endif // LEMON_ERROR_H
[1067]478
479#undef LEMON_ASSERT
480#undef LEMON_FIXME
481
482#ifndef LEMON_ASSERT_ABORT
483#  define LEMON_ASSERT_ABORT 1
484#endif
485
486#ifndef LEMON_ASSERT_HANDLER
[1120]487#  ifdef LEMON_ASSERT_EXCEPTION
488#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_throw
489#  else
490#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail
491#  endif
[1067]492#endif
493
494#if defined(NDEBUG) || defined(LEMON_DISABLE_ASSERTS)
495
496#  define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))
497
498#else
499
500/**
501 * \brief Macro for assertions with customizable message
502 *
[1120]503 * Macro for assertions with customizable message.
504 *
505 * The behaviour can be customized with LEMON_ASSERT_HANDLER,
506 * LEMON_ASSERT_EXCEPTION and LEMON_ASSERT_ABORT defines. Asserts can be
507 * disabled by defining either NDEBUG or LEMON_DISABLE_ASSERTS macros.
508 *
509 * \todo We should provide some way to reset to the default behaviour,
510 * shouldn't we?
511 *
512 * \todo This whole 'assert' business should be placed in a separate
513 * include file.
514 *
[1067]515 * \todo __PRETTY_FUNCTION__ should be replaced by something
[1274]516 * compiler-independent, like BOOST_CURRENT_FUNCTION
[1067]517 */
518
519#  define LEMON_ASSERT(exp, msg)                 \
520     (static_cast<void> (!!(exp) ? 0 : (         \
521       LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
522                            __PRETTY_FUNCTION__, \
523                            (msg), #exp, LEMON_ASSERT_ABORT), 0)))
524
[1120]525#endif // NDEBUG || LEMON_DISABLE_ASSERTS
[1067]526
527/**
528 * \brief Macro for mark not yet implemented features.
529 *
530 * \todo Is this the right place for this? It should be used only in
531 * modules under development.
532 *
533 * \todo __PRETTY_FUNCTION__ should be replaced by something
[1274]534 * compiler-independent, like BOOST_CURRENT_FUNCTION
[1067]535 */
536
537# define LEMON_FIXME(msg) \
538    (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
539                          "FIXME: " msg))
Note: See TracBrowser for help on using the repository browser.