/* -*- C++ -*-

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

  *

  * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Combinatorial Optimization Research Group, 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 misc

 //! \file

 //! \brief Basic error handling (signaling) routines.

 #include <exception>

 #include <string>

 #include <sstream>

 #include <boost/shared_ptr.hpp>

 namespace lemon {

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

   class ErrorMessage {

   protected:

   ///\e 

     boost::shared_ptr<std::ostringstream> buf;

   ///\e 

     bool init() throw() {

       try {

 	buf.reset(new std::ostringstream);

       }

       catch(...) {

 	buf.reset();

       }

       return buf;

     }

   public:

   ///\e 

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

   ///\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 ) return *this;

       try {

 	*buf << t;

       }

       catch(...) {

 	buf.reset();

       }

     }

   ///\e 

     const char* message() throw() {

       if( !buf ) 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 ErrorMessage {

   public:

   ///\e 

     Exception() throw() {}

   ///\e 

     explicit Exception(const std::string &s) throw()

       : ErrorMessage(s) {}

   ///\e 

     virtual ~Exception() throw() {}

   ///\e 

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

       const char *mes = message();

       if( mes ) return mes;

       return "lemon::Exception";

     }

   };

   ///\e 

   class LogicError : public Exception {

   ///\e 

     explicit LogicError(const std::string &s)

       : Exception(s) {}

   };

   ///\e 

   class RuntimeError : public Exception {

   ///\e 

     explicit RuntimeError(const std::string &s)

       : Exception(s) {}

   };

   ///\e 

   class RangeError : public RuntimeError {

   ///\e 

     explicit RangeError(const std::string &s)

       : RuntimeError(s) {}

   };

   ///\e 

   class IOError : public RuntimeError {

   ///\e 

     explicit IOError(const std::string &s)

       : RuntimeError(s) {}

   };

   ///\e 

   class DataFormatError : public IOError {

   ///\e 

     explicit DataFormatError(const std::string &message)

       : IOError(message) : line(0) {}

   ///\e 

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

 		    const std::string &message)

       : IOError(message), line(line_num) { set_file(file_name); }

   ///\e 

     void set_line(int line_num) { line=line_num; }

   ///\e 

     void set_file(const std::string &file_name) {

       try {

 	file.reset(new std::string);

 	*file = file_name;

       }

       catch(...) {

 	file.reset();

       }

     }

   ///\e 

     virtual const char* what() const {

       const char *mes = 0;

       try {

 	std::ostringstream ostr;

 	ostr << IOError::what();

 	if( file || line ) {

 	  ostr << " (";

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

 	  if( line ) ostr << " at line" << line;

 	}

 	mes = ostr.str().c_str();

       }

       catch(...) {}

       if( mes ) return mes;

       return "lemon::DataFormatError";

     }

   };

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

   /**

    * \brief Macro for assertions with customizable message

    */

 # define lemon_assert(exp, msg) \

     if(!(exp)) { \

       std::cerr << __FILE__ ":" << __LINE__ << ": " << (msg) << std::endl; \

       abort; \

     }

   /**

    * \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.

    */

 # define FIXME(msg) lemon_assert(0, "FIXME: " msg)

 }

 #endif // LEMON_ERROR_H