COIN-OR::LEMON - Graph Library

source: lemon-0.x/src/lemon/error.h @ 1359:1581f961cfaa

Last change on this file since 1359:1581f961cfaa was 1359:1581f961cfaa, checked in by Alpar Juttner, 15 years ago

Correct the english name of EGRES.

File size: 12.6 KB
Line 
1/* -*- C++ -*-
2 *
3 * src/lemon/error.h - Part of LEMON, a generic C++ optimization library
4 *
5 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi
6 * Kutatocsoport (Egervary Research Group on Combinatorial Optimization,
7 * 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
33namespace 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) {
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  };
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    ///\todo The good solution is boost:shared_ptr...
105    mutable
106    std::auto_ptr<std::ostringstream> buf;
107   
108    ///\e
109    bool init() throw() {
110      try {
111        buf.reset(new std::ostringstream);
112      }
113      catch(...) {
114        buf.reset();
115      }
116      return buf.get();
117    }
118
119  public:
120
121    ///\e
122    ErrorMessage() throw() { init(); }
123
124    ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
125
126    ///\e
127    ErrorMessage(const char *message) throw() {
128      init();
129      *this << message;
130    }
131
132    ///\e
133    ErrorMessage(const std::string &message) throw() {
134      init();
135      *this << message;
136    }
137
138    ///\e
139    template <typename T>
140    ErrorMessage& operator<<(const T &t) throw() {
141      if( ! buf.get() ) return *this;
142
143      try {
144        *buf << t;
145      }
146      catch(...) {
147        buf.reset();
148      }
149      return *this;
150    }
151
152    ///\e
153    const char* message() throw() {
154      if( ! buf.get() ) return 0;
155
156      const char* mes = 0;
157      try {
158        mes = buf->str().c_str();
159      }
160      catch(...) {}
161      return mes;
162    }
163   
164  };
165
166  /**
167   * \brief 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
178    ///\e
179    virtual const char* exceptionName() const {
180      return "lemon::Exception";
181    }
182   
183    ///\e
184    virtual const char* what() const throw() {
185      return exceptionName();
186    }
187  };
188
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   *
196   * A typical example for this is \ref UninitializedParameter.
197   */
198  class LogicError : public Exception {
199  public:
200    virtual const char* exceptionName() const {
201      return "lemon::LogicError";
202    }
203  };
204
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
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   */
226  class RuntimeError : public Exception {
227  public:
228    virtual const char* exceptionName() const {
229      return "lemon::RuntimeError";
230    }
231  };
232
233  ///\e
234  class RangeError : public RuntimeError {
235  public:
236    virtual const char* exceptionName() const {
237      return "lemon::RangeError";
238    }
239  };
240
241  ///\e
242  class IOError : public RuntimeError {
243  public:
244    virtual const char* exceptionName() const {
245      return "lemon::IOError";
246    }
247  };
248
249  ///\e
250  class DataFormatError : public IOError {
251  protected:
252    ExceptionMember<std::string> _message;
253    ExceptionMember<std::string> _file;
254    int _line;
255
256    mutable ExceptionMember<std::string> _message_holder;
257  public:
258
259    DataFormatError(const DataFormatError &dfe) :
260      IOError(dfe), _message(dfe._message), _file(dfe._file),
261      _line(dfe._line) {}
262
263    ///\e
264    explicit DataFormatError(const char *the_message)
265      : _message(the_message), _line(0) {}
266
267    ///\e
268    DataFormatError(const std::string &file_name, int line_num,
269                    const char *the_message)
270      : _message(the_message), _line(line_num) { file(file_name); }
271
272    ///\e
273    void line(int line) { _line = line; }
274    ///\e
275    void message(const std::string& message) { _message.set(message); }
276    ///\e
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;
287      }
288    }
289
290    /// \brief Returns the filename.
291    ///
292    /// Returns \e null if the filename was not specified.
293    const char* file() const {
294      if (_file.valid() && !_file.get().empty()) {
295        return _file.get().c_str();
296      } else {
297        return 0;
298      }
299    }
300
301    ///\e
302    virtual const char* what() const throw() {
303      try {
304        std::ostringstream ostr;
305        if (message()) ostr << message();
306        if( file() || line() != 0 ) {
307          ostr << " (";
308          if( file() ) ostr << "in file '" << file() << "'";
309          if( file() && line() != 0 ) ostr << " ";
310          if( line() != 0 ) ostr << "at line " << line();
311          ostr << ")";
312        }
313        _message_holder.set(ostr.str());
314      }
315      catch (...) {}
316      if( _message_holder.valid()) return _message_holder.get().c_str();
317      return exceptionName();
318    }
319
320    virtual const char* exceptionName() const {
321      return "lemon::DataFormatError";
322    }
323
324    virtual ~DataFormatError() throw() {}
325  };
326
327  class IOParameterError : public LogicError {
328  protected:
329    ExceptionMember<std::string> _message;
330    ExceptionMember<std::string> _file;
331
332    mutable ExceptionMember<std::string> _message_holder;
333  public:
334
335    IOParameterError(const IOParameterError &ile) :
336      LogicError(ile), _message(ile._message), _file(ile._file) {}
337
338    ///\e
339    explicit IOParameterError(const char *the_message)
340      : _message(the_message) {}
341
342    ///\e
343    IOParameterError(const char *file_name, const char *the_message)
344      : _message(file_name), _file(file_name) {}
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 {
385      return "lemon::IOParameterError";
386    }
387
388    virtual ~IOParameterError() throw() {}
389  };
390
391
392  ///\e
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;
400
401    mutable ExceptionMember<std::string> _message_holder;
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 )
429           ostr << " (assertion '" << assertion << "' failed)";
430        _message_holder.set(ostr.str());
431        return ostr.str().c_str();
432      }
433      catch(...) {}
434      if( _message_holder.valid() ) return _message_holder.get().c_str();
435      return exceptionName();
436    }
437
438    virtual const char* exceptionName() const {
439      return "lemon::AssertionFailedError";
440    }
441
442    virtual ~AssertionFailedError() throw() {}
443  };
444
445
446  /****************  Macros  ****************/
447
448
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  }
465
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  }
473
474/// @}
475
476}
477#endif // LEMON_ERROR_H
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
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
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 *
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 *
515 * \todo __PRETTY_FUNCTION__ should be replaced by something
516 * compiler-independent, like BOOST_CURRENT_FUNCTION
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
525#endif // NDEBUG || LEMON_DISABLE_ASSERTS
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
534 * compiler-independent, like BOOST_CURRENT_FUNCTION
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.