Update INSTALL file.
1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
3 * This file is a part of LEMON, a generic C++ optimization library.
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
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) throw() {
70 if (ptr.get() == 0) return;
72 if (!copy.valid()) return;
77 void set(const Type& type) throw() {
78 if (ptr.get() == 0) return;
84 const Type& get() const {
88 bool valid() const throw() {
89 return ptr.get() != 0;
93 std::auto_ptr<_Type> ptr;
96 /// Exception-safe convenient error message builder 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).
105 ///\todo The good solution is boost::shared_ptr...
107 mutable std::auto_ptr<std::ostringstream> buf;
110 bool init() throw() {
112 buf.reset(new std::ostringstream);
123 ErrorMessage() throw() { init(); }
125 ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
128 ErrorMessage(const char *msg) throw() {
134 ErrorMessage(const std::string &msg) throw() {
140 template <typename T>
141 ErrorMessage& operator<<(const T &t) throw() {
142 if( ! buf.get() ) return *this;
154 const char* message() throw() {
155 if( ! buf.get() ) return 0;
159 mes = buf->str().c_str();
167 /// Generic exception class.
169 /// Base class for exceptions used in LEMON.
171 class Exception : public std::exception {
176 virtual ~Exception() throw() {}
178 virtual const char* what() const throw() {
179 return "lemon::Exception";
183 /// One of the two main subclasses of \ref Exception.
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).
189 /// A typical example for this is \ref UninitializedParameter.
190 class LogicError : public Exception {
192 virtual const char* what() const throw() {
193 return "lemon::LogicError";
197 /// \ref Exception for uninitialized parameters.
199 /// This error represents problems in the initialization
200 /// of the parameters of the algorithms.
201 class UninitializedParameter : public LogicError {
203 virtual const char* what() const throw() {
204 return "lemon::UninitializedParameter";
209 /// One of the two main subclasses of \ref Exception.
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 {
216 virtual const char* what() const throw() {
217 return "lemon::RuntimeError";
222 class RangeError : public RuntimeError {
224 virtual const char* what() const throw() {
225 return "lemon::RangeError";
230 class IoError : public RuntimeError {
232 virtual const char* what() const throw() {
233 return "lemon::IoError";
238 class DataFormatError : public IoError {
240 ExceptionMember<std::string> _message;
241 ExceptionMember<std::string> _file;
244 mutable ExceptionMember<std::string> _message_holder;
247 DataFormatError(const DataFormatError &dfe) :
248 IoError(dfe), _message(dfe._message), _file(dfe._file),
252 explicit DataFormatError(const char *the_message)
253 : _message(the_message), _line(0) {}
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); }
261 void line(int ln) { _line = ln; }
263 void message(const std::string& msg) { _message.set(msg); }
265 void file(const std::string &fl) { _file.set(fl); }
268 int line() const { return _line; }
270 const char* message() const {
271 if (_message.valid() && !_message.get().empty()) {
272 return _message.get().c_str();
278 /// \brief Returns the filename.
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();
290 virtual const char* what() const throw() {
292 std::ostringstream ostr;
293 ostr << "lemon:DataFormatError" << ": ";
294 if (message()) ostr << message();
295 if( file() || line() != 0 ) {
297 if( file() ) ostr << "in file '" << file() << "'";
298 if( file() && line() != 0 ) ostr << " ";
299 if( line() != 0 ) ostr << "at line " << line();
302 _message_holder.set(ostr.str());
305 if( _message_holder.valid()) return _message_holder.get().c_str();
306 return "lemon:DataFormatError";
309 virtual ~DataFormatError() throw() {}
313 class FileOpenError : public IoError {
315 ExceptionMember<std::string> _file;
317 mutable ExceptionMember<std::string> _message_holder;
320 FileOpenError(const FileOpenError &foe) :
321 IoError(foe), _file(foe._file) {}
324 explicit FileOpenError(const std::string& fl)
329 void file(const std::string &fl) { _file.set(fl); }
331 /// \brief Returns the filename.
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();
343 virtual const char* what() const throw() {
345 std::ostringstream ostr;
346 ostr << "lemon::FileOpenError" << ": ";
347 ostr << "Cannot open file - " << file();
348 _message_holder.set(ostr.str());
351 if( _message_holder.valid()) return _message_holder.get().c_str();
352 return "lemon::FileOpenError";
354 virtual ~FileOpenError() throw() {}
357 class IoParameterError : public IoError {
359 ExceptionMember<std::string> _message;
360 ExceptionMember<std::string> _file;
362 mutable ExceptionMember<std::string> _message_holder;
365 IoParameterError(const IoParameterError &ile) :
366 IoError(ile), _message(ile._message), _file(ile._file) {}
369 explicit IoParameterError(const char *the_message)
370 : _message(the_message) {}
373 IoParameterError(const char *file_name, const char *the_message)
374 : _message(the_message), _file(file_name) {}
377 void message(const std::string& msg) { _message.set(msg); }
379 void file(const std::string &fl) { _file.set(fl); }
382 const char* message() const {
383 if (_message.valid()) {
384 return _message.get().c_str();
390 /// \brief Returns the filename.
392 /// Returns \c 0 if the filename was not specified.
393 const char* file() const {
395 return _file.get().c_str();
402 virtual const char* what() const throw() {
404 std::ostringstream ostr;
405 if (message()) ostr << message();
406 if (file()) ostr << "(when reading file '" << file() << "')";
407 _message_holder.set(ostr.str());
410 if( _message_holder.valid() ) return _message_holder.get().c_str();
411 return "lemon:IoParameterError";
413 virtual ~IoParameterError() throw() {}
420 #endif // LEMON_ERROR_H