Easy input-output function for common graphs.
Modified Exception handling in graph_reader.
3 * src/lemon/error.h - Part of LEMON, a generic C++ optimization library
5 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi
6 * Kutatocsoport (Egervary Combinatorial Optimization Research Group,
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.
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
22 //! \ingroup exceptions
24 //! \brief Basic exception classes and error handling.
35 /// \addtogroup exceptions
38 /// \brief Exception safe wrapper class.
40 /// Exception safe wrapper class to implement the members of exceptions.
41 template <typename _Type>
42 class ExceptionMember {
46 ExceptionMember() throw () {
48 ptr.reset(new Type());
52 ExceptionMember(const Type& type) throw () {
54 ptr.reset(new Type());
55 if (ptr.get() == 0) return;
60 ExceptionMember(const ExceptionMember& copy) throw() {
62 if (!copy.valid()) return;
63 ptr.reset(new Type());
64 if (ptr.get() == 0) return;
69 ExceptionMember& operator=(const ExceptionMember& copy) {
70 if (ptr.get() == 0) return;
72 if (!copy.valid()) return;
77 void set(const Type& type) {
78 if (ptr.get() == 0) return;
84 const Type& get() const {
89 return ptr.get() != 0;
93 std::auto_ptr<_Type> ptr;
96 /// Exception-safe convenient "error message" class.
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).
104 ///\todo The good solution is boost:shared_ptr...
106 std::auto_ptr<std::ostringstream> buf;
109 bool init() throw() {
111 buf.reset(new std::ostringstream);
122 ErrorMessage() throw() { init(); }
124 ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
127 ErrorMessage(const char *message) throw() {
133 ErrorMessage(const std::string &message) throw() {
139 template <typename T>
140 ErrorMessage& operator<<(const T &t) throw() {
141 if( ! buf.get() ) return *this;
153 const char* message() throw() {
154 if( ! buf.get() ) return 0;
158 mes = buf->str().c_str();
167 * \brief Generic exception class.
169 * Base class for exceptions used in LEMON.
171 class Exception : public std::exception {
176 virtual ~Exception() throw() {}
179 virtual const char* exceptionName() const {
180 return "lemon::Exception";
184 virtual const char* what() const throw() {
185 return exceptionName();
190 * \brief One of the two main subclasses of \ref Exception.
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).
196 * A typical example for this is \ref UninitializedParameter.
198 class LogicError : public Exception {
200 virtual const char* exceptionName() const {
201 return "lemon::LogicError";
206 * \brief \ref Exception for uninitialized parameters.
208 * This error represents problems in the initialization
209 * of the parameters of the algorithms.
211 class UninitializedParameter : public LogicError {
213 virtual const char* exceptionName() const {
214 return "lemon::UninitializedParameter";
220 * \brief One of the two main subclasses of \ref Exception.
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.
226 class RuntimeError : public Exception {
228 virtual const char* exceptionName() const {
229 return "lemon::RuntimeError";
234 class RangeError : public RuntimeError {
236 virtual const char* exceptionName() const {
237 return "lemon::RangeError";
242 class IOError : public RuntimeError {
244 virtual const char* exceptionName() const {
245 return "lemon::IOError";
250 class DataFormatError : public IOError {
252 ExceptionMember<std::string> _message;
253 ExceptionMember<std::string> _file;
256 mutable ExceptionMember<std::string> _message_holder;
259 DataFormatError(const DataFormatError &dfe) :
260 IOError(dfe), _message(dfe._message), _file(dfe._file),
264 explicit DataFormatError(const char *the_message)
265 : _message(the_message), _line(0) {}
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); }
273 void line(int line) { _line = line; }
275 void message(const std::string& message) { _message.set(message); }
277 void file(const std::string &file) { _file.set(file); }
280 int line() const { return _line; }
282 const char* message() const {
283 if (_message.valid() && !_message.get().empty()) {
284 return _message.get().c_str();
290 /// \brief Returns the filename.
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();
302 virtual const char* what() const throw() {
304 std::ostringstream ostr;
305 if (message()) ostr << message();
306 if( file() || line() != 0 ) {
308 if( file() ) ostr << "in file '" << file() << "'";
309 if( file() && line() != 0 ) ostr << " ";
310 if( line() != 0 ) ostr << "at line " << line();
313 _message_holder.set(ostr.str());
316 if( _message_holder.valid()) return _message_holder.get().c_str();
317 return exceptionName();
320 virtual const char* exceptionName() const {
321 return "lemon::DataFormatError";
324 virtual ~DataFormatError() throw() {}
327 class IOLogicError : public IOError, public LogicError {
329 ExceptionMember<std::string> _message;
330 ExceptionMember<std::string> _file;
333 mutable ExceptionMember<std::string> _message_holder;
336 IOLogicError(const IOLogicError &ile) :
337 IOError(ile), LogicError(ile),
338 _message(ile._message), _file(ile._file) {}
341 explicit IOLogicError(const char *the_message)
342 : _message(the_message), _line(0) {}
345 IOLogicError(const char *file_name, const char *the_message)
346 : _message(file_name), _file(file_name) {}
349 void message(const std::string& message) { _message.set(message); }
351 void file(const std::string &file) { _file.set(file); }
354 const char* message() const {
355 if (_message.valid()) {
356 return _message.get().c_str();
362 /// \brief Returns the filename.
364 /// Returns \e null if the filename was not specified.
365 const char* file() const {
367 return _file.get().c_str();
374 virtual const char* what() const throw() {
376 std::ostringstream ostr;
377 if (message()) ostr << message();
378 if (file()) ostr << "(when reading file '" << file() << "')";
379 _message_holder.set(ostr.str());
382 if( _message_holder.valid() ) return _message_holder.get().c_str();
383 return exceptionName();
386 virtual const char* exceptionName() const {
387 return "lemon::IOLogicError";
390 virtual ~IOLogicError() throw() {}
395 class AssertionFailedError : public LogicError {
397 const char *assertion;
400 const char *function;
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),
410 const char* get_assertion() const { return assertion; }
412 const char* get_message() const { return message; }
414 const char* get_file() const { return file; }
416 const char* get_function() const { return function; }
418 int get_line() const { return line; }
421 virtual const char* what() const throw() {
424 std::ostringstream ostr;
425 ostr << file << ":" << line << ": ";
427 ostr << function << ": ";
430 ostr << " (assertion '" << assertion << "' failed)";
431 mes = ostr.str().c_str();
432 /// \bug Szerintem a 'mes'-re nem szabad hivatkozni, mert
433 /// az elobb felszabadul.
436 if( mes ) return mes;
437 return exceptionName();
440 virtual const char* exceptionName() const {
441 return "lemon::AssertionFailedError";
444 virtual ~AssertionFailedError() throw() {}
448 /**************** Macros ****************/
452 void assert_fail(const char *file, int line, const char *func,
453 const char *message, const char *assertion = 0,
457 cerr << file << ":" << line << ": ";
459 cerr << func << ": ";
462 cerr << " (assertion '" << assertion << "' failed)";
469 void assert_fail_throw(const char *file, int line, const char *func,
470 const char *message, const char *assertion = 0,
473 throw AssertionFailedError(file, line, func, message, assertion);
479 #endif // LEMON_ERROR_H
484 #ifndef LEMON_ASSERT_ABORT
485 # define LEMON_ASSERT_ABORT 1
488 #ifndef LEMON_ASSERT_HANDLER
489 # ifdef LEMON_ASSERT_EXCEPTION
490 # define LEMON_ASSERT_HANDLER ::lemon::assert_fail_throw
492 # define LEMON_ASSERT_HANDLER ::lemon::assert_fail
496 #if defined(NDEBUG) || defined(LEMON_DISABLE_ASSERTS)
498 # define LEMON_ASSERT(exp, msg) (static_cast<void> (0))
503 * \brief Macro for assertions with customizable message
505 * Macro for assertions with customizable message.
507 * The behaviour can be customized with LEMON_ASSERT_HANDLER,
508 * LEMON_ASSERT_EXCEPTION and LEMON_ASSERT_ABORT defines. Asserts can be
509 * disabled by defining either NDEBUG or LEMON_DISABLE_ASSERTS macros.
511 * \todo We should provide some way to reset to the default behaviour,
514 * \todo This whole 'assert' business should be placed in a separate
517 * \todo __PRETTY_FUNCTION__ should be replaced by something
518 * compiler-independant, like BOOST_CURRENT_FUNCTION
521 # define LEMON_ASSERT(exp, msg) \
522 (static_cast<void> (!!(exp) ? 0 : ( \
523 LEMON_ASSERT_HANDLER(__FILE__, __LINE__, \
524 __PRETTY_FUNCTION__, \
525 (msg), #exp, LEMON_ASSERT_ABORT), 0)))
527 #endif // NDEBUG || LEMON_DISABLE_ASSERTS
530 * \brief Macro for mark not yet implemented features.
532 * \todo Is this the right place for this? It should be used only in
533 * modules under development.
535 * \todo __PRETTY_FUNCTION__ should be replaced by something
536 * compiler-independant, like BOOST_CURRENT_FUNCTION
539 # define LEMON_FIXME(msg) \
540 (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, __PRETTY_FUNCTION__, \