/* -*- C++ -*-

 * lemon/error.h - Part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi

 * Kutatocsoport (Egervary Research Group on Combinatorial Optimization,

 * EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_ERROR_H

#define LEMON_ERROR_H

//! \ingroup exceptions

//! \file

//! \brief Basic exception classes and error handling.

#include <exception>

#include <string>

#include <sstream>

#include <iostream>

#include <cstdlib>

#include <memory>

namespace lemon {

  /// \addtogroup exceptions

  /// @{

  /// \brief Exception safe wrapper class.

  ///

  /// Exception safe wrapper class to implement the members of exceptions.

  template <typename _Type>

  class ExceptionMember {

  public:

    typedef _Type Type;

    ExceptionMember() throw () {

      try {

	ptr.reset(new Type());

      } catch (...) {}

    }

    ExceptionMember(const Type& type) throw () {

      try {

	ptr.reset(new Type());

	if (ptr.get() == 0) return;

	*ptr = type;

      } catch (...) {}

    }

    ExceptionMember(const ExceptionMember& copy) throw() {

      try {

	if (!copy.valid()) return;

	ptr.reset(new Type());

	if (ptr.get() == 0) return;

	*ptr = copy.get();

      } catch (...) {}

    }

    ExceptionMember& operator=(const ExceptionMember& copy) {

      if (ptr.get() == 0) return;

      try {

	if (!copy.valid()) return;

 	*ptr = copy.get();

      } catch (...) {}

    }

    void set(const Type& type) {

      if (ptr.get() == 0) return;

      try {

	*ptr = type;

      } catch (...) {}

    }

    const Type& get() const {

      return *ptr;

    }

    bool valid() const {

      return ptr.get() != 0;

    }

  private:

    std::auto_ptr<_Type> ptr;

  };

  /// Exception-safe convenient "error message" class.

  /// Helper class which provides a convenient ostream-like (operator <<

  /// based) interface to create a string message. Mostly useful in

  /// exception classes (therefore the name).

  class ErrorMessage {

  protected:

    ///\e 

    ///\todo The good solution is boost::shared_ptr...

    ///

    mutable

    std::auto_ptr<std::ostringstream> buf;

    ///\e 

    bool init() throw() {

      try {

	buf.reset(new std::ostringstream);

      }

      catch(...) {

	buf.reset();

      }

      return buf.get();

    }

  public:

    ///\e 

    ErrorMessage() throw() { init(); }

    ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }

    ///\e 

    ErrorMessage(const char *message) throw() {

      init();

      *this << message;

    }

    ///\e 

    ErrorMessage(const std::string &message) throw() {

      init();

      *this << message;

    }

    ///\e 

    template <typename T>

    ErrorMessage& operator<<(const T &t) throw() {

      if( ! buf.get() ) return *this;

      try {

	*buf << t;

      }

      catch(...) {

	buf.reset();

      }

      return *this;

    }

    ///\e 

    const char* message() throw() {

      if( ! buf.get() ) return 0;

      const char* mes = 0;

      try {

	mes = buf->str().c_str();

      }

      catch(...) {}

      return mes;

    }

  };

  /**

   * \brief Generic exception class.

   *

   * Base class for exceptions used in LEMON.

   */

  class Exception : public std::exception {

  public:

    ///\e 

    Exception() {}

    ///\e 

    virtual ~Exception() throw() {}

    ///\e

    virtual const char* exceptionName() const {

      return "lemon::Exception";

    }

    ///\e 

    virtual const char* what() const throw() {

      return exceptionName();

    }

  };

  /**

   * \brief One of the two main subclasses of \ref Exception.

   *

   * Logic errors represent problems in the internal logic of a program;

   * in theory, these are preventable, and even detectable before the

   * program runs (e.g., violations of class invariants).

   *

   * A typical example for this is \ref UninitializedParameter.

   */

  class LogicError : public Exception {

  public:

    virtual const char* exceptionName() const {

      return "lemon::LogicError";

    }

  };

  /**

   * \brief \ref Exception for uninitialized parameters.

   *

   * This error represents problems in the initialization

   * of the parameters of the algorithms.

   */

  class UninitializedParameter : public LogicError {

  public:

    virtual const char* exceptionName() const {

      return "lemon::UninitializedParameter";

    }

  };

  /**

   * \brief One of the two main subclasses of \ref Exception.

   *

   * Runtime errors represent problems outside the scope of a program;

   * they cannot be easily predicted and can generally only be caught as

   * the program executes.

   */

  class RuntimeError : public Exception {

  public:

    virtual const char* exceptionName() const {

      return "lemon::RuntimeError";

    }

  };

  ///\e

  class RangeError : public RuntimeError {

  public:

    virtual const char* exceptionName() const {

      return "lemon::RangeError";

    }

  };

  ///\e 

  class IOError : public RuntimeError {

  public:

    virtual const char* exceptionName() const {

      return "lemon::IOError";

    }

  };

  ///\e 

  class DataFormatError : public IOError {

  protected:

    ExceptionMember<std::string> _message;

    ExceptionMember<std::string> _file;

    int _line;

    mutable ExceptionMember<std::string> _message_holder;

  public:

    DataFormatError(const DataFormatError &dfe) : 

      IOError(dfe), _message(dfe._message), _file(dfe._file),

      _line(dfe._line) {}

    ///\e 

    explicit DataFormatError(const char *the_message)

      : _message(the_message), _line(0) {}

    ///\e 

    DataFormatError(const std::string &file_name, int line_num,

		    const char *the_message)

      : _message(the_message), _line(line_num) { file(file_name); }

    ///\e 

    void line(int line) { _line = line; }

    ///\e 

    void message(const std::string& message) { _message.set(message); }

    ///\e 

    void file(const std::string &file) { _file.set(file); }

    ///\e

    int line() const { return _line; }

    ///\e

    const char* message() const { 

      if (_message.valid() && !_message.get().empty()) {

	return _message.get().c_str();

      } else {

	return 0;

      }

    }

    /// \brief Returns the filename.

    ///

    /// Returns \e null if the filename was not specified.

    const char* file() const {

      if (_file.valid() && !_file.get().empty()) {

	return _file.get().c_str();

      } else {

	return 0;

      }

    }

    ///\e 

    virtual const char* what() const throw() {

      try {

	std::ostringstream ostr;

	ostr << exceptionName() << ": ";

	if (message()) ostr << message();

	if( file() || line() != 0 ) {

	  ostr << " (";

	  if( file() ) ostr << "in file '" << file() << "'";

	  if( file() && line() != 0 ) ostr << " ";

	  if( line() != 0 ) ostr << "at line " << line();

	  ostr << ")";

	}

	_message_holder.set(ostr.str());

      }

      catch (...) {}

      if( _message_holder.valid()) return _message_holder.get().c_str();

      return exceptionName();

    }

    virtual const char* exceptionName() const {

      return "lemon::DataFormatError";

    }

    virtual ~DataFormatError() throw() {}

  };

  ///\e 

  class FileOpenError : public IOError {

  protected:

    ExceptionMember<std::string> _file;

    mutable ExceptionMember<std::string> _message_holder;

  public:

    FileOpenError(const FileOpenError &foe) : 

      IOError(foe), _file(foe._file) {}

    ///\e 

    explicit FileOpenError(const std::string& file)

      : _file(file) {}

    ///\e 

    void file(const std::string &file) { _file.set(file); }

    /// \brief Returns the filename.

    ///

    /// Returns \e null if the filename was not specified.

    const char* file() const {

      if (_file.valid() && !_file.get().empty()) {

	return _file.get().c_str();

      } else {

	return 0;

      }

    }

    ///\e 

    virtual const char* what() const throw() {

      try {

	std::ostringstream ostr;

	ostr << exceptionName() << ": ";

	ostr << "Cannot open file - " << file();

	_message_holder.set(ostr.str());

      }

      catch (...) {}

      if( _message_holder.valid()) return _message_holder.get().c_str();

      return exceptionName();

    }

    virtual const char* exceptionName() const {

      return "lemon::FileOpenError";

    }

    virtual ~FileOpenError() throw() {}

  };

  class IOParameterError : public IOError {

  protected:

    ExceptionMember<std::string> _message;

    ExceptionMember<std::string> _file;

    mutable ExceptionMember<std::string> _message_holder;

  public:

    IOParameterError(const IOParameterError &ile) : 

      IOError(ile), _message(ile._message), _file(ile._file) {}

    ///\e 

    explicit IOParameterError(const char *the_message)

      : _message(the_message) {}

    ///\e 

    IOParameterError(const char *file_name, const char *the_message)

      : _message(the_message), _file(file_name) {}

     ///\e 

    void message(const std::string& message) { _message.set(message); }

    ///\e 

    void file(const std::string &file) { _file.set(file); }

     ///\e

    const char* message() const { 

      if (_message.valid()) {

	return _message.get().c_str();

      } else {

	return 0;

      }

    }

    /// \brief Returns the filename.

    ///

    /// Returns \e null if the filename was not specified.

    const char* file() const {

      if (_file.valid()) {

	return _file.get().c_str();

      } else {

	return 0;

      }

    }

    ///\e 

    virtual const char* what() const throw() {

      try {

	std::ostringstream ostr;

	if (message()) ostr << message();

	if (file()) ostr << "(when reading file '" << file() << "')";

	_message_holder.set(ostr.str());

      }

      catch (...) {}

      if( _message_holder.valid() ) return _message_holder.get().c_str();

      return exceptionName();

    }

    virtual const char* exceptionName() const {

      return "lemon::IOParameterError";

    }

    virtual ~IOParameterError() throw() {}

  };

  ///\e

  class AssertionFailedError : public LogicError {

  protected:

    const char *assertion;

    const char *file;

    int line;

    const char *function;

    const char *message;

    mutable ExceptionMember<std::string> _message_holder;

  public:

    ///\e

    AssertionFailedError(const char *_file, int _line, const char *func,

			 const char *msg, const char *_assertion = 0) :

      assertion(_assertion), file(_file), line(_line), function(func),

      message(msg) {}

    ///\e

    const char* get_assertion() const { return assertion; }

    ///\e

    const char* get_message() const { return message; }

    ///\e

    const char* get_file() const { return file; }

    ///\e

    const char* get_function() const { return function; }

    ///\e

    int get_line() const { return line; }

    virtual const char* what() const throw() {

      try {

	std::ostringstream ostr;

	ostr << file << ":" << line << ": ";

	if( function )

	  ostr << function << ": ";

	ostr << message;

	if( assertion )

	   ostr << " (assertion '" << assertion << "' failed)";

	_message_holder.set(ostr.str());

	return ostr.str().c_str();

      }

      catch(...) {}

      if( _message_holder.valid() ) return _message_holder.get().c_str();

      return exceptionName();

    }

    virtual const char* exceptionName() const {

      return "lemon::AssertionFailedError";

    }

    virtual ~AssertionFailedError() throw() {}

  };

  /****************  Macros  ****************/

  template <typename Exception>

  inline void assert_fail(const char *file, int line, const char *func,

		   Exception exception, const char *assertion = 0,

		   bool do_abort=true)

  {

    using namespace std;

    cerr << file << ":" << line << ": ";

    if( func )

      cerr << func << ": ";

    cerr << exception.what();

    if( assertion )

      cerr << " (assertion '" << assertion << "' failed)";

    cerr << endl;

    if(do_abort)

      abort();

  }

  template <>

  inline void assert_fail<const char *>(const char *file, int line, const char *func,

				 const char *message, 

				 const char *assertion,

				 bool do_abort)

  {

    using namespace std;

    cerr << file << ":" << line << ": ";

    if( func )

      cerr << func << ": ";

    cerr << message;

    if( assertion )

      cerr << " (assertion '" << assertion << "' failed)";

    cerr << endl;

    if(do_abort)

      abort();

  }

  template <typename Exception>

  inline void assert_fail_failure(const char *file, int line, const char *func,

			   Exception exception, 

			   const char *assertion = 0,

			   bool = true)

  {

    throw AssertionFailedError(file, line, func, exception.what(), assertion);

  }

  template <>

  inline void assert_fail_failure<const char *>(const char *file, int line, 

					 const char *func,

					 const char *message, 

					 const char *assertion,

					 bool)

  {

    throw AssertionFailedError(file, line, func, message, assertion);

  }

  template <typename Exception> 

  inline void assert_fail_exception(const char *file, int line, const char *func,

			     Exception exception, 

			     const char *assertion = 0, bool = true)

  {

    throw exception;

  }

  template <> 

  inline void assert_fail_exception<const char *>(const char *file, int line, 

					   const char *func,

					   const char *message, 

					   const char *assertion,

					   bool)

  {

    throw AssertionFailedError(file, line, func, message, assertion);

  }

/// @}

}

#endif // LEMON_ERROR_H

#undef LEMON_ASSERT

#undef LEMON_FIXME

#ifndef LEMON_ASSERT_ABORT

#  define LEMON_ASSERT_ABORT 1

#endif

#ifndef LEMON_ASSERT_HANDLER

#  if defined LEMON_ASSERT_EXCEPTION

#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception

#  elif defined LEMON_ASSERT_FAILURE

#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_failure

#  else

#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail

#  endif

#endif

#if defined(NDEBUG) || defined(LEMON_DISABLE_ASSERTS)

#  define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))

#else

/**

 * \brief Macro for assertions with customizable message

 *

 * Macro for assertions with customizable message.

 *

 * The behaviour can be customized with LEMON_ASSERT_HANDLER,

 * LEMON_ASSERT_EXCEPTION and LEMON_ASSERT_ABORT defines. Asserts can be

 * disabled by defining either NDEBUG or LEMON_DISABLE_ASSERTS macros.

 *

 * \todo We should provide some way to reset to the default behaviour,

 * shouldn't we?

 *

 * \todo This whole 'assert' business should be placed in a separate

 * include file. The boost assert is not guarded by header sentries

 * which may help to change the behaviour of the assertions in 

 * the files.

 *

 * \todo __PRETTY_FUNCTION__ should be replaced by something

 * compiler-independent, like BOOST_CURRENT_FUNCTION

 */

#  define LEMON_ASSERT(exp, msg)                 \

     (static_cast<void> (!!(exp) ? 0 : (         \

       LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \

                            __PRETTY_FUNCTION__, \

			    msg, #exp, LEMON_ASSERT_ABORT), 0)))

#endif // NDEBUG || LEMON_DISABLE_ASSERTS

/**

 * \brief Macro for mark not yet implemented features.

 *

 * \todo Is this the right place for this? It should be used only in

 * modules under development.

 *

 * \todo __PRETTY_FUNCTION__ should be replaced by something

 * compiler-independent, like BOOST_CURRENT_FUNCTION

 */

# define LEMON_FIXME(msg) \

    (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, __PRETTY_FUNCTION__, \

			  "FIXME: " msg))