#ifndef LEMON_ERROR_H

 #ifndef LEMON_ASSERT_H

 #define LEMON_ERROR_H

 #define LEMON_ASSERT_H

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

 /// \brief Extended assertion handling

 #include <exception>

 #include <lemon/error.h>

 #include <string>

 #include <sstream>

 #include <iostream>

 #include <cstdlib>

 #include <memory>

   /// \brief Exception safe wrapper class.

   ///\e

   ///

   class AssertionFailedError : public LogicError {

   /// 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" 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 {

     ///\e

     const char *_assertion;

     const char *_file;

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

     ///\e

     DataFormatError(const DataFormatError &dfe) :

     AssertionFailedError(const char *file, int line, const char *function,

       IoError(dfe), _message(dfe._message), _file(dfe._file),

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

       _line(dfe._line) {}

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

       _function(function), _message(msg) {}

     ///\e

     explicit DataFormatError(const char *the_message)

     ///\e

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

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

     ///\e

     ///\e

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

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

     ///\e

 		    const char *the_message)

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

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

     ///\e

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

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

     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

 	ostr << "lemon:DataFormatError" << ": ";

 	ostr << _file << ":" << _line << ": ";

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

 	if (_function)

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

 	  ostr << _function << ": ";

 	  ostr << " (";

 	ostr << _message;

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

 	if (_assertion)

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

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

 	  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() {}

   };

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

    virtual ~AssertionFailedError() throw() {}

     virtual ~AssertionFailedError() throw() {}

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

   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);

   }

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

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

                           const char *func,

 				    const Exception& exception,

                           Exception exception,

 				    const char *, const std::exception* = 

                           const char *assertion = 0,

 				    static_cast<const Exception*>(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 <>

   inline void assert_fail<std::string>(const char *file, int line,

                                        const char *func,

                                        std::string message,

                                        const char *assertion,

                                        bool do_abort)

   {

     assert_fail(file, line, func, message.c_str(), assertion, do_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 <>

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

                                                const char *func,

                                                std::string message,

                                                const char *assertion,

                                                bool)

   {

     assert_fail_failure(file, line, func, message.c_str(), assertion, true);

   }

   template <typename Exception>

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

 			     Exception exception,

 			     const char *assertion = 0, bool = true)

   template <>

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

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

 				    const char *function, const char *message,

 					   const char *func,

 				    const char *assertion)

 					   const char *message,

   {

 					   const char *assertion,

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

 					   bool)

   }

   {

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

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

   }

 				    const char *function, 

 				    const std::string& message,

   template <>

 				    const char *assertion)

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

   {

                                                  const char *func,

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

                                                  std::string message,

                                                  const char *assertion,

                                                  bool)

   {

     assert_fail_exception(file, line, func, message.c_str(), assertion, true);

 #endif // LEMON_ERROR_H

 #endif // LEMON_ASSERT_H

 #ifdef LEMON_ENABLE_ASSERTS

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

 #  define LEMON_ASSERT_ABORT

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

 #endif

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

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

 #ifndef LEMON_ASSERT_DO_ABORT

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

 #  define LEMON_ASSERT_DO_ABORT 1

 #error "Lemon assertion system is not set properly"

 #endif

 #endif

 #ifndef LEMON_ASSERT_HANDLER

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

 #  if defined LEMON_ASSERT_EXCEPTION

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

 #    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception

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

 #  elif defined LEMON_ASSERT_FAILURE

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

 #    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_failure

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

 #  elif defined LEMON_ASSERT_ABORT

      defined(LEMON_ENABLE_ASSERT)) &&			\

 #    define LEMON_ASSERT_HANDLER ::lemon::assert_fail

   defined(LEMON_DISABLE_ASSERTS)

 #  else

 #error "Lemon assertion system is not set properly"

 #    define LEMON_DISABLE_ASSERTS

 #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"

 /// 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.

 /// enable the assertions with the

 /// enable the assertions with the following code:

 /// Then an assert

 /// or with compilation parameters:

 /// provides a log on the standard error about the assertion and aborts

 /// \code

 /// the program if LEMON_ASSERT_DO_ABORT is also defined (otherwise the

 /// g++ -DLEMON_ENABLE_ASSERTS

 /// program keeps on running).

 /// make CXXFLAGS='-DLEMON_ENABLE_ASSERTS'

 /// By defining LEMON_ASSERT_FAILURE or

 /// \endcode

 /// LEMON_ASSERT_EXCEPTION, you can set other behaviour to the

 /// 

 /// assertions. In case LEMON_ASSERT_FAILURE is given, LEMON_ASSERT

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

 /// will always throw an \c AssertionFailedError exception with

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

 /// the \c msg error message. By using

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

 /// LEMON_ASSERT_EXCEPTION, one can define an arbitrary exception to be thrown.

 ///

 ///

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

 /// The LEMON_ASSERT macro should be called with the \c exp parameter

 ///

 /// which should be an expression convertible to bool. If the given

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

 /// parameter is false the assertion is raised and one of the assertion

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

 /// behaviour will be activated. The \c msg should be either a const

 ///   execution.

 /// char* message or an exception. When the \c msg is an exception the

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

 /// \ref lemon::Exception::what() "what()" function is called to retrieve and

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

 /// display the error message.

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

 ///

 ///   LEMON_ENABLE_ASSERTS.

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

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

 /// shouldn't we?

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

 ///

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

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

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

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

 ///   error message.

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

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

 /// the files.

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

 ///

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

 /// \todo __PRETTY_FUNCTION__ should be replaced by something

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

 /// compiler-independent, like BOOST_CURRENT_FUNCTION

 ///   the given parameter.

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

 #  define LEMON_ASSERT(exp, msg)                 \

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

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

 ///   with the following parameter lists:

        LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \

 ///   \code

                             __PRETTY_FUNCTION__, \

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

                             msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))

 ///                                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)))

 #  if defined LEMON_DISABLE_ASSERTS

 #  ifndef LEMON_ASSERT_HANDLER

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

                               __PRETTY_FUNCTION__, \

                               LEMON_FUNCTION_NAME, \

                               msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))

                               msg, #exp), 0)))

 #    define LEMON_FIXME(msg) \

        (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,	\

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

 #endif

 #endif

 /**

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