/* -*- C++ -*-

  *

  * 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_ASSERT_H

 #define LEMON_ASSERT_H

 /// \ingroup exceptions

 /// \file

 /// \brief Extended assertion handling

 #include <lemon/error.h>

 namespace lemon {

   /// @{

   ///\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 *function,

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

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

       _function(function), _message(msg) {}

     ///\e

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

     ///\e

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

     ///\e

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

     ///\e

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

     ///\e

     int 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 "lemon::AssertionFailedError";

     }

     virtual ~AssertionFailedError() throw() {}

   };

   inline void assert_fail_log(const char *file, int line,

 			      const char *function,

 			      const std::exception& exception, 

 			      const char *assertion)

   {

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

     if (function)

       std::cerr << function << ": ";

     std::cerr << exception.what();

     if (assertion)

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

     std::cerr << std::endl;

   }

   inline void assert_fail_log(const char *file, int line, const char *function,

 			      const char *message, const char *assertion)

   {

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

     if (function)

       std::cerr << function << ": ";

     std::cerr << message;

     if (assertion)

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

     std::cerr << std::endl;

   }

   inline void assert_fail_log(const char *file, int line, const char *function, 

 			      const std::string& message, const char *assertion)

   {

     assert_fail_log(file, line, function, message.c_str(), assertion);

   }

   inline void assert_fail_abort(const char *file, int line, 

 				const char *function,

 				const std::exception& exception,

 				const char *assertion)

   {

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

     if (function)

       std::cerr << function << ": ";

     std::cerr << exception.what();

     if (assertion)

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

     std::cerr << std::endl;

     std::abort();

   }

   inline void assert_fail_abort(const char *file, int line,

 				const char *function, const char* message,

 				const char *assertion)

   {

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

     if (function)

       std::cerr << function << ": ";

     std::cerr << message;

     if (assertion)

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

     std::cerr << std::endl;

     std::abort();

   }

   inline void assert_fail_abort(const char *file, int line, 

 				const char *function, 

 				const std::string& message,

 				const char *assertion)

   {

     assert_fail_abort(file, line, function, message.c_str(), assertion);

   }

   inline void assert_fail_error(const char *file, int line, 

 				  const char *function,

 				  const std::exception& exception,

 				  const char *assertion)

   {

     throw AssertionFailedError(file, line, function, 

 			       exception.what(), assertion);

   }

   inline void assert_fail_error(const char *file, int line,

 				  const char *function, const char *message,

 				  const char *assertion)

   {

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

   }

   inline void assert_fail_error(const char *file, int line,

 				  const char *function, 

 				  const std::string& message,

 				  const char *assertion)

   {

     assert_fail_error(file, line, function, message.c_str(), assertion);

   }

   template <typename Exception>

   inline void assert_fail_exception(const char *, int, const char *,

 				    const Exception& exception,

 				    const char *, const std::exception* = 

 				    static_cast<const Exception*>(0))

   {

     throw exception;

   }

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

 				    const char *function, const char *message,

 				    const char *assertion)

   {

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

   }

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

 				    const char *function, 

 				    const std::string& message,

 				    const char *assertion)

   {

     assert_fail_exception(file, line, function, message.c_str(), assertion);

   }

 /// @}

 }

 #endif // LEMON_ASSERT_H

 #undef LEMON_ASSERT

 #undef LEMON_FIXME

 #if (defined(LEMON_ASSERT_LOG) ? 1 : 0) +		\

   (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +		\

   (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +		\

   (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +		\

   (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1

 #error "Lemon assertion system is not set properly"

 #endif

 #if ((defined(LEMON_ASSERT_LOG) ? 1 : 0) +		\

      (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +		\

      (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +		\

      (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +	\

      (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||	\

      defined(LEMON_ENABLE_ASSERT)) &&			\

   defined(LEMON_DISABLE_ASSERTS)

 #error "Lemon assertion system is not set properly"

 #endif

 #if defined LEMON_ASSERT_LOG

 #  undef LEMON_ASSERT_HANDLER

 #  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_log

 #elif defined LEMON_ASSERT_ABORT

 #  undef LEMON_ASSERT_HANDLER

 #  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort

 #elif defined LEMON_ASSERT_ERROR

 #  undef LEMON_ASSERT_HANDLER

 #  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_error

 #elif defined LEMON_ASSERT_EXCEPTION

 #  undef LEMON_ASSERT_HANDLER

 #  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception

 #elif defined LEMON_ASSERT_CUSTOM

 #  undef LEMON_ASSERT_HANDLER

 #  ifndef LEMON_CUSTOM_ASSERT_HANDLER

 #    error "LEMON_CUSTOM_ASSERT_HANDLER is not set"

 #  endif

 #  define LEMON_ASSERT_HANDLER LEMON_CUSTOM_ASSERT_HANDLER

 #elif defined LEMON_ENABLE_ASSERTS

 #  undef LEMON_ASSERT_HANDLER

 #  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort

 #else

 #  undef LEMON_ASSERT_HANDLER

 #endif

 #ifndef LEMON_FUNCTION_NAME

 #  define LEMON_FUNCTION_NAME (__PRETTY_FUNCTION__)

 #endif

 #ifdef DOXYGEN

 /// \ingroup exceptions

 ///

 /// \brief Macro for assertions with customizable message

 ///

 /// Macro for assertions with customizable message.  

 /// \param exp An expression convertible to bool. If the expression is

 /// false, then an assertion is raised. The concrete behaviour depends

 /// on the settings of the assertion system.

 /// \param msg A \e const \e char*, a \e const std::string& or a \e

 /// const \e std::exception& parameter. The variable can be used to

 /// provide information about the circumstances of failed assertion.

 ///

 /// The assertions are disabled in the default behaviour. You can

 /// enable the assertions with the following code:

 /// \code

 /// #define LEMON_ENABLE_ASSERTS

 /// \endcode

 /// or with compilation parameters:

 /// \code

 /// g++ -DLEMON_ENABLE_ASSERTS

 /// make CXXFLAGS='-DLEMON_ENABLE_ASSERTS'

 /// \endcode

 /// 

 /// The %lemon assertion system has a wide range of customization

 /// properties. As default behaviour the failed assertion prints a

 /// short log message to the standard ouput and aborts the execution.

 ///

 /// The following modes can be used in the assertion system: 

 ///

 /// - \e LEMON_ASSERT_LOG The failed assert print a short convenient

 ///   error message to the standard error and continues the

 ///   execution.

 /// - \e LEMON_ASSERT_ABORT This mode is similar to the \e

 ///   LEMON_ASSERT_LOG, but it aborts the program. It is the default

 ///   operation mode when the asserts are enabled with \e

 ///   LEMON_ENABLE_ASSERTS.

 /// - \e LEMON_ASSERT_ERROR The assert throws an \ref

 ///   lemon::AssertionFailedError "AssertionFailedError". If the \c

 ///   msg parameter is an exception, then the result of the \ref

 ///   lemon::Exception::what() "what()" member function is passed as

 ///   error message.

 /// - \e LEMON_ASSERT_EXCEPTION If the specified \c msg is an

 ///   exception then it raised directly (solving that the exception

 ///   can not be thrown polymorphically), otherwise an \ref

 ///   lemon::AssertionFailedError "AssertionFailedError" is thrown with

 ///   the given parameter.

 /// - \e LEMON_ASSERT_CUSTOM The user can define an own assertion

 ///   handler functions. Three overloaded functions should be defined

 ///   with the following parameter lists:

 ///   \code

 ///     void custom_assert_handler(const char* file, int line, 

 ///                                const char* function, const char* message, const char* expression);

 ///     void custom_assert_handler(const char* file, int line, 

 ///                                const char* function, const std::string& message, const char* expression);

 ///     void custom_assert_handler(const char* file, int line, 

 ///                                const char* function, const std::exception& message, const char* expression);

 ///   \endcode

 ///   The name of the functions should be defined as the \c

 ///   LEMON_CUSTOM_ASSERT_HANDLER macro name. 

 ///   \code

 ///     #define LEMON_CUSTOM_ASSERT_HANDLER custom_assert_handler

 ///   \endcode

 ///   Whenever an assertion is occured, one of the custom assertion

 ///   handler is called with appropiate parameters.

 ///

 /// The assertion mode can be changed within one compilation unit, if

 /// the macros are redefined with other settings and the

 /// lemon/assert.h file is reincluded then the behaviour is changed

 /// appropiately to the new settings.

 #  define LEMON_ASSERT(exp, msg)					\

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

     LEMON_ASSERT_HANDLER(__FILE__, __LINE__,				\

 			 LEMON_FUNCTION_NAME,				\

 			 msg, #exp), 0)))

 /// \ingroup exceptions

 ///

 /// \brief Macro for mark not yet implemented features.

 ///

 /// Macro for mark not yet implemented features and outstanding bugs.

 /// It is close to be the shortcut of the following code:

 /// \code

 ///   LEMON_ASSERT(false, msg);

 /// \endcode

 #  define LEMON_FIXME(msg)						\

        (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,	\

 			     "FIXME: " msg, static_cast<const char*>(0)))

 #else

 #  ifndef LEMON_ASSERT_HANDLER

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

 #    define LEMON_FIXME(msg) (static_cast<void>(0))

 #  else

 #    define LEMON_ASSERT(exp, msg)                 \

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

          LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \

                               LEMON_FUNCTION_NAME, \

                               msg, #exp), 0)))

 #    define LEMON_FIXME(msg) \

        (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,	\

 			     "FIXME: " msg,  static_cast<const char*>(0)))

 #  endif

 #endif