/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2008

 * 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) throw() {

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

      try {

        if (!copy.valid()) return;

        *ptr = copy.get();

      } catch (...) {}

    }

    void set(const Type& type) throw() {

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

      try {

        *ptr = type;

      } catch (...) {}

    }

    const Type& get() const {

      return *ptr;

    }

    bool valid() const throw() {

      return ptr.get() != 0;

    }

  private:

    std::auto_ptr<_Type> ptr;

  };

  /// Exception-safe convenient error message builder 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 *msg) throw() {

      init();

      *this << msg;

    }

    ///\e

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

      init();

      *this << msg;

    }

    ///\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;

    }

  };

  /// 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* what() const throw() {

      return "lemon::Exception";

    }

  };

  /// 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* what() const throw() {

      return "lemon::LogicError";

    }

  };

  /// \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* what() const throw() {

      return "lemon::UninitializedParameter";

    }

  };

  /// 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* what() const throw() {

      return "lemon::RuntimeError";

    }

  };

  ///\e

  class RangeError : public RuntimeError {

  public:

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

      return "lemon::RangeError";

    }

  };

  ///\e

  class IoError : public RuntimeError {

  public:

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

      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 ln) { _line = ln; }

    ///\e

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

    ///\e

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

    ///\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 << "lemon:DataFormatError" << ": ";

        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 "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& fl)

      : _file(fl) {}

    ///\e

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

    /// \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 << "lemon::FileOpenError" << ": ";

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

        _message_holder.set(ostr.str());

      }

      catch (...) {}

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

      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& msg) { _message.set(msg); }

    ///\e

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

     ///\e

    const char* message() const {

      if (_message.valid()) {

        return _message.get().c_str();

      } else {

        return 0;

      }

    }

    /// \brief Returns the filename.

    ///

    /// Returns \c 0 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 "lemon:IoParameterError";

    }

    virtual ~IoParameterError() throw() {}

  };

  /// @}

}

#endif // LEMON_ERROR_H