Changes in / [122:35840c5aa696:121:91c0fed3181e] in lemon

Files:

• lemon/assert.h (modified) (6 diffs)
• lemon/bits/utility.h (modified) (2 diffs)
• lemon/concepts/heap.h (modified) (7 diffs)
• lemon/concepts/maps.h (modified) (2 diffs)
• lemon/random.h (modified) (2 diffs)
• test/error_test.cc (modified) (6 diffs)

lemon/assert.h

@@ -27 +27 @@
 
 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,
@@ -40 +105 @@
   }
 
+  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)
   {
-    assert_fail_log(file, line, function, message, 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();
   }
 
-  namespace _assert_bits {
-    
-    
-    inline const char* cstringify(const std::string& str) {
-      return str.c_str();
-    }
-
-    inline const char* cstringify(const char* str) {
-      return str;
-    }    
-  }
+  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
-#undef LEMON_DEBUG
 
 #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"
+#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_ASSERTS)) &&                  \
-  (defined(LEMON_DISABLE_ASSERTS) ||                    \
-   defined(NDEBUG))
-#error "LEMON assertion system is not set properly"
+     defined(LEMON_ENABLE_ASSERT)) &&                   \
+  defined(LEMON_DISABLE_ASSERTS)
+#error "Lemon assertion system is not set properly"
 #endif
 
@@ -89 +229 @@
 #  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
@@ -95 +241 @@
 #  endif
 #  define LEMON_ASSERT_HANDLER LEMON_CUSTOM_ASSERT_HANDLER
-#elif defined LEMON_DISABLE_ASSERTS
-#  undef LEMON_ASSERT_HANDLER
-#elif defined NDEBUG
-#  undef LEMON_ASSERT_HANDLER
+#elif defined LEMON_ENABLE_ASSERTS
+#  undef LEMON_ASSERT_HANDLER
+#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
 #else
-#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
-#endif
+#  undef LEMON_ASSERT_HANDLER
+#endif
+
 
 #ifndef LEMON_FUNCTION_NAME
@@ -111 +257 @@
 /// \ingroup exceptions
 ///
-/// \brief Macro for assertion with customizable message
-///
-/// Macro for assertion with customizable message.  \param exp An
-/// expression that must be convertible to \c bool.  If it is \c
+/// \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 <tt>const
-/// char*</tt> parameter, which can be used to provide information
-/// about the circumstances of the failed assertion.
-///
-/// The assertions are enabled in the default behaviour.
-/// You can disable them with the following code:
+/// 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_DISABLE_ASSERTS
+/// #define LEMON_ENABLE_ASSERTS
 /// \endcode
 /// or with compilation parameters:
 /// \code
-/// g++ -DLEMON_DISABLE_ASSERTS
-/// make CXXFLAGS='-DLEMON_DISABLE_ASSERTS'
+/// g++ -DLEMON_ENABLE_ASSERTS
+/// make CXXFLAGS='-DLEMON_ENABLE_ASSERTS'
 /// \endcode
-/// The checking is also disabled when the standard macro \c NDEBUG is defined.
 /// 
-/// The LEMON assertion system has a wide range of customization
-/// properties. As a default behaviour the failed assertion prints a
-/// short log message to the standard error and aborts the execution.
+/// 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: 
 ///
-/// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
-///   message to the standard error and continues the execution.
-/// - \c LEMON_ASSERT_ABORT This mode is similar to the \c
+/// - \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
-///   behaviour.
-/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
-///   function.
+///   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* assertion);
+///     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 function should be defined as the \c
+///   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, the custom assertion
+///   Whenever an assertion is occured, one of the custom assertion
 ///   handler is called with appropiate parameters.
 ///
-/// The assertion mode can also be changed within one compilation unit.
-/// If the macros are redefined with other settings and the
-/// \ref lemon/assert.h "assert.h" file is reincluded, then the
-/// behaviour is changed appropiately to the new settings.
+/// 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,                           \
-                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
+                         msg, #exp), 0)))
+
 
 /// \ingroup exceptions
@@ -176 +340 @@
 ///   LEMON_ASSERT(false, msg);
 /// \endcode
-///
-/// \see LEMON_ASSERT 
 #  define LEMON_FIXME(msg)                                              \
-  (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \
-                        ::lemon::_assert_bits::cstringify(msg),         \
-                        static_cast<const char*>(0)))
-
-/// \ingroup exceptions
-///
-/// \brief Macro for internal assertions
-///
-/// Macro for internal assertions, it is used in the library to check
-/// the consistency of results of algorithms, several pre- and
-/// postconditions and invariants. The checking is disabled by
-/// default, but it can be turned on with the macro \c
-/// LEMON_ENABLE_DEBUG.
-/// \code
-/// #define LEMON_ENABLE_DEBUG
-/// \endcode
-/// or with compilation parameters:
-/// \code
-/// g++ -DLEMON_ENABLE_DEBUG
-/// make CXXFLAGS='-DLEMON_ENABLE_DEBUG'
-/// \endcode
-///
-/// This macro works like the \c LEMON_ASSERT macro, therefore the
-/// current behaviour depends on the settings of \c LEMON_ASSERT
-/// macro.
-///
-/// \see LEMON_ASSERT 
-#  define LEMON_DEBUG(exp, msg)                                         \
-  (static_cast<void> (!!(exp) ? 0 : (                                   \
-    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
-                         LEMON_FUNCTION_NAME,                           \
-                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
+       (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_ASSERT(exp, msg)  (static_cast<void> (0))
 #    define LEMON_FIXME(msg) (static_cast<void>(0))
-#    define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
 #  else
-#    define LEMON_ASSERT(exp, msg)                                      \
-       (static_cast<void> (!!(exp) ? 0 : (                              \
-        LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                        \
-                             LEMON_FUNCTION_NAME,                       \
-                             ::lemon::_assert_bits::cstringify(msg),    \
-                             #exp), 0)))
-#    define LEMON_FIXME(msg)                                            \
+#    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,   \
-                             ::lemon::_assert_bits::cstringify(msg),    \
-                             static_cast<const char*>(0)))
-
-#    if LEMON_ENABLE_DEBUG
-#      define LEMON_DEBUG(exp, msg)
-         (static_cast<void> (!!(exp) ? 0 : (         \
-           LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
-                                LEMON_FUNCTION_NAME, \
-                                ::lemon::_assert_bits::cstringify(msg), \
-                                #exp), 0)))
-#    else
-#      define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
-#    endif
+                             "FIXME: " msg,  static_cast<const char*>(0)))
 #  endif
 
 #endif
 
-#ifdef DOXYGEN
-
-
-#else
-
-
-#endif
-
-
+

lemon/bits/utility.h

@@ -22 +22 @@
 // Boost enable_if library
 
-// Copyright 2003 (c) The Trustees of Indiana University.
+// Copyright 2003 © The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to the Boost Software
@@ -28 +28 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
-//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Järvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

lemon/concepts/heap.h

@@ -19 +19 @@
 ///\ingroup concept
 ///\file
-///\brief The concept of heaps.
+///\brief Classes for representing heaps.
+///
 
 #ifndef LEMON_CONCEPT_HEAP_H
@@ -27 +28 @@
 
 namespace lemon {
-
   namespace concepts {
-
     /// \addtogroup concept
     /// @{
 
-    /// \brief The heap concept.
+
+    /// \brief A concept structure describes the main interface of heaps.
     ///
-    /// Concept class describing the main interface of heaps.
-    template <typename Priority, typename ItemIntMap>
+    /// A concept structure describes the main interface of heaps.
+    ///
+    template <typename Prio, typename ItemIntMap>
     class Heap {
     public:
 
-      /// Type of the items stored in the heap.
-      typedef typename ItemIntMap::Key Item;
-
-      /// Type of the priorities.
-      typedef Priority Prio;
-
-      /// \brief Type to represent the states of the items.
-      ///
-      /// Each item has a state associated to it. It can be "in heap",
-      /// "pre heap" or "post heap". The later two are indifferent
-      /// from the point of view of the heap, but may be useful for
-      /// the user.
-      ///
-      /// The \c ItemIntMap must be initialized in such a way, that it 
-      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
+      ///\brief Type of the items stored in the heap.
+      typedef typename ItemIntMap::Key  Item;
+  
+
+      /// \brief Type to represent the items states.
+      ///
+      /// Each Item element have a state associated to it. It may be "in heap",
+      /// "pre heap" or "post heap". The later two are indifferent from the
+      /// heap's point of view, but may be useful to the user.
+      ///
+      /// The ItemIntMap _should_ be initialized in such way, that it maps
+      /// PRE_HEAP (-1) to any element to be put in the heap...
       enum State {
         IN_HEAP = 0,
@@ -64 +62 @@
       ///
       /// The constructor.
-      /// \param map A map that assigns \c int values to keys of type
-      /// \c Item. It is used internally by the heap implementations to
-      /// handle the cross references. The assigned value must be
-      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
-      explicit Heap(ItemIntMap &map) {}
+      /// \param _iim should be given to the constructor, since it is used
+      /// internally to handle the cross references. The value of the map
+      /// should be PRE_HEAP (-1) for each element.
+      explicit Heap(ItemIntMap &_iim) {}
 
       /// \brief The number of items stored in the heap.
@@ -75 +72 @@
       int size() const { return 0; }
 
-      /// \brief Checks if the heap is empty.
-      ///
-      /// Returns \c true if the heap is empty.
+      /// \brief Checks if the heap stores no items.
+      ///
+      /// Returns \c true if and only if the heap stores no items.
       bool empty() const { return false; }
 
-      /// \brief Makes the heap empty.
-      ///
-      /// Makes the heap empty.
+      /// \brief Makes empty this heap.
+      ///
+      /// Makes this heap empty.
       void clear();
 
-      /// \brief Inserts an item into the heap with the given priority.
+      /// \brief Insert an item into the heap with the given heap.
       ///    
-      /// Inserts the given item into the heap with the given priority. 
+      /// Adds \c i to the heap with priority \c p. 
       /// \param i The item to insert.
       /// \param p The priority of the item.
       void push(const Item &i, const Prio &p) {}
 
-      /// \brief Returns the item having minimum priority.
-      ///
-      /// Returns the item having minimum priority.
-      /// \pre The heap must be non-empty.
+      /// \brief Returns the item with minimum priority.
+      ///
+      /// This method returns the item with minimum priority.  
+      /// \pre The heap must be nonempty.  
       Item top() const {}
 
-      /// \brief The minimum priority.
-      ///
-      /// Returns the minimum priority.
-      /// \pre The heap must be non-empty.
+      /// \brief Returns the minimum priority.
+      ///
+      /// It returns the minimum priority.
+      /// \pre The heap must be nonempty.
       Prio prio() const {}
 
-      /// \brief Removes the item having minimum priority.
-      ///
-      /// Removes the item having minimum priority.
-      /// \pre The heap must be non-empty.
+      /// \brief Deletes the item with minimum priority.
+      ///
+      /// This method deletes the item with minimum priority.
+      /// \pre The heap must be non-empty.  
       void pop() {}
 
-      /// \brief Removes an item from the heap.
-      ///
-      /// Removes the given item from the heap if it is already stored.
-      /// \param i The item to delete. 
+      /// \brief Deletes \c i from the heap.
+      ///
+      /// This method deletes item \c i from the heap, if \c i was
+      /// already stored in the heap.
+      /// \param i The item to erase. 
       void erase(const Item &i) {}
 
-      /// \brief The priority of an item.
-      ///
-      /// Returns the priority of the given item.  
+      /// \brief Returns the priority of \c i.
+      ///
+      /// This function returns the priority of item \c i.  
       /// \pre \c i must be in the heap.
       /// \param i The item.
       Prio operator[](const Item &i) const {}
 
-      /// \brief Sets the priority of an item or inserts it, if it is
-      /// not stored in the heap.
-      ///
-      /// This method sets the priority of the given item if it is
-      /// already stored in the heap.
-      /// Otherwise it inserts the given item with the given priority.
-      ///
-      /// It may throw an \ref UnderflowPriorityException.
+      /// \brief \c i gets to the heap with priority \c p independently 
+      /// if \c i was already there.
+      ///
+      /// This method calls \ref push(\c i, \c p) if \c i is not stored
+      /// in the heap and sets the priority of \c i to \c p otherwise.
+      /// It may throw an \e UnderFlowPriorityException. 
       /// \param i The item.
       /// \param p The priority.
       void set(const Item &i, const Prio &p) {}
       
-      /// \brief Decreases the priority of an item to the given value.
-      ///
-      /// Decreases the priority of an item to the given value.
+      /// \brief Decreases the priority of \c i to \c p.
+      ///
+      /// This method decreases the priority of item \c i to \c p.
       /// \pre \c i must be stored in the heap with priority at least \c p.
       /// \param i The item.
@@ -143 +139 @@
       void decrease(const Item &i, const Prio &p) {}
 
-      /// \brief Increases the priority of an item to the given value.
-      ///
-      /// Increases the priority of an item to the given value.
-      /// \pre \c i must be stored in the heap with priority at most \c p.
+      /// \brief Increases the priority of \c i to \c p.
+      ///
+      /// This method sets the priority of item \c i to \c p. 
+      /// \pre \c i must be stored in the heap with priority at most \c
+      /// p relative to \c Compare.
       /// \param i The item.
       /// \param p The priority.
       void increase(const Item &i, const Prio &p) {}
 
-      /// \brief Returns if an item is in, has already been in, or has
+      /// \brief Returns if \c item is in, has already been in, or has 
       /// never been in the heap.
       ///
-      /// This method returns \c PRE_HEAP if the given item has never
-      /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-      /// and \c POST_HEAP otherwise.
-      /// In the latter case it is possible that the item will get back
-      /// to the heap again.
+      /// This method returns PRE_HEAP if \c item has never been in the
+      /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+      /// otherwise. In the latter case it is possible that \c item will
+      /// get back to the heap again.
       /// \param i The item.
       State state(const Item &i) const {}
 
-      /// \brief Sets the state of an item in the heap.
-      ///
-      /// Sets the state of the given item in the heap. It can be used
-      /// to manually clear the heap when it is important to achive the
+      /// \brief Sets the state of the \c item in the heap.
+      ///
+      /// Sets the state of the \c item in the heap. It can be used to
+      /// manually clear the heap when it is important to achive the
       /// better time complexity.
       /// \param i The item.
-      /// \param st The state. It should not be \c IN_HEAP.
+      /// \param st The state. It should not be \c IN_HEAP. 
       void state(const Item& i, State st) {}
 
@@ -175 +171 @@
       struct Constraints {
       public:
+    
         void constraints() {
-          typedef typename _Heap::Item OwnItem;
-          typedef typename _Heap::Prio OwnPrio;
-          typedef typename _Heap::State OwnState;
-
           Item item;
           Prio prio;
-          State state;
+
           item=Item();
           prio=Prio();
+
           ignore_unused_variable_warning(item);
           ignore_unused_variable_warning(prio);
+
+          typedef typename _Heap::State State;
+          State state;
+
           ignore_unused_variable_warning(state);
-
-          OwnItem own_item;
-          OwnPrio own_prio;
-          OwnState own_state;
-          own_item=Item();
-          own_prio=Prio();
-          ignore_unused_variable_warning(own_item);
-          ignore_unused_variable_warning(own_prio);
-          ignore_unused_variable_warning(own_state);
-
-          _Heap heap1(map);
-          _Heap heap2 = heap1;
+      
+          _Heap heap1 = _Heap(map);
+
           ignore_unused_variable_warning(heap1);
-          ignore_unused_variable_warning(heap2);
-          
-          int s = heap.size();
-          bool e = heap.empty();
+      
+          heap.push(item, prio);
 
           prio = heap.prio();
           item = heap.top();
-          prio = heap[item];
-          own_prio = heap.prio();
-          own_item = heap.top();
-          own_prio = heap[own_item];
-
-          heap.push(item, prio);
-          heap.push(own_item, own_prio);
+
           heap.pop();
 
@@ -220 +201 @@
           heap.decrease(item, prio);
           heap.increase(item, prio);
-          heap.set(own_item, own_prio);
-          heap.decrease(own_item, own_prio);
-          heap.increase(own_item, own_prio);
+          prio = heap[item];
 
           heap.erase(item);
-          heap.erase(own_item);
-          heap.clear();
 
           state = heap.state(item);
-          heap.state(item, state);
-          state = heap.state(own_item);
-          heap.state(own_item, own_state);
 
           state = _Heap::PRE_HEAP;
           state = _Heap::IN_HEAP;
           state = _Heap::POST_HEAP;
-          own_state = _Heap::PRE_HEAP;
-          own_state = _Heap::IN_HEAP;
-          own_state = _Heap::POST_HEAP;
+
+          heap.clear();
         }
-
+    
         _Heap& heap;
         ItemIntMap& map;
+
+        Constraints() : heap(0), map(0) {}
       };
     };

lemon/concepts/maps.h

@@ -25 +25 @@
 ///\ingroup concept
 ///\file
-///\brief The concept of maps.
+///\brief Map concepts checking classes for testing and documenting.
 
 namespace lemon {
@@ -106 +106 @@
         const Value& val;
         const typename _WriteMap::Key& own_key;
-        const typename _WriteMap::Value& own_val;
+        const typename _WriteMap::Value own_val;
         _WriteMap& m;
       };

lemon/random.h

@@ -796 +796 @@
           }
       } while(nu>std::pow(xi,delta-1.0)*std::exp(-xi));
-      return theta*(xi+gamma(int(std::floor(k))));
+      return theta*(xi-gamma(int(std::floor(k))));
     }
     
@@ -820 +820 @@
     double pareto(double k,double x_min)
     {
-      return exponential(gamma(k,1.0/x_min))+x_min;
+      return exponential(gamma(k,1.0/x_min));
     }  
       

test/error_test.cc

@@ -40 +40 @@
 }
 
+void no_assertion_exception_disable() {
+  LEMON_ASSERT(true, Exception());
+}
+
 void assertion_text_disable() {
   LEMON_ASSERT(false, "This is a fault message");
+}
+
+void assertion_exception_disable() {
+  LEMON_ASSERT(false, Exception());
 }
 
@@ -50 +58 @@
 void check_assertion_disable() {
   no_assertion_text_disable();
+  no_assertion_exception_disable();
+  assertion_exception_disable();
   assertion_text_disable();
   fixme_disable();
 }
 #undef LEMON_DISABLE_ASSERTS
+
+
+#define LEMON_ASSERT_ERROR
+#include <lemon/assert.h>
+
+void no_assertion_text_error() {
+  LEMON_ASSERT(true, "This is a fault message");
+}
+
+void no_assertion_exception_error() {
+  LEMON_ASSERT(true, Exception());
+}
+
+void assertion_text_error() {
+  LEMON_ASSERT(false, "This is a fault message");
+}
+
+void assertion_exception_error() {
+  LEMON_ASSERT(false, Exception());
+}
+
+void fixme_error() {
+  LEMON_FIXME("fixme_error() is fixme!");
+}
+
+void check_assertion_error() {
+  no_assertion_text_error();
+  no_assertion_exception_error();
+  try {
+    assertion_exception_error();
+    check(false, "Assertion error");
+  } catch (const AssertionFailedError& e) {
+  }
+
+  try {
+    assertion_text_error();
+    check(false, "Assertion error");
+  } catch (const AssertionFailedError& e) {
+  }
+
+  try {
+    fixme_error();
+    check(false, "Assertion error");
+  } catch (const AssertionFailedError& e) {
+  }
+}
+#undef LEMON_ASSERT_ERROR
+
+#define LEMON_ASSERT_EXCEPTION
+#include <lemon/assert.h>
+
+void no_assertion_text_exception() {
+  LEMON_ASSERT(true, "This is a fault message");
+}
+
+void no_assertion_exception_exception() {
+  LEMON_ASSERT(true, Exception());
+}
+
+void assertion_text_exception() {
+  LEMON_ASSERT(false, "This is a fault message");
+}
+
+void assertion_exception_exception() {
+  LEMON_ASSERT(false, Exception());
+}
+
+void fixme_exception() {
+  LEMON_FIXME("fixme_exception() is fixme!");
+}
+
+void check_assertion_exception() {
+  no_assertion_text_exception();
+  no_assertion_exception_exception();
+  try {
+    assertion_exception_exception();
+    check(false, "Assertion error");
+  } catch (const Exception& e) {
+  }
+
+  try {
+    assertion_text_exception();
+    check(false, "Assertion error");
+  } catch (const AssertionFailedError& e) {
+  }
+
+  try {
+    assertion_text_exception();
+    check(false, "Assertion error");
+  } catch (const AssertionFailedError& e) {
+  }
+
+  try {
+    fixme_exception();
+    check(false, "Assertion error");
+  } catch (const AssertionFailedError& e) {
+  }
+}
+#undef LEMON_ASSERT_EXCEPTION
+
+#define LEMON_ASSERT_LOG
+
+#include <lemon/assert.h>
+
+void no_assertion_text_log() {
+  LEMON_ASSERT(true, "This is a fault message");
+}
+
+void no_assertion_exception_log() {
+  LEMON_ASSERT(true, Exception());
+}
+
+void assertion_text_log() {
+  LEMON_ASSERT(false, "This is a fault message");
+}
+
+void assertion_exception_log() {
+  LEMON_ASSERT(false, Exception());
+}
+
+void fixme_log() {
+  LEMON_FIXME("fixme_log() is fixme!");
+}
+
+void check_assertion_log() {
+  no_assertion_text_log();
+  no_assertion_exception_log();
+  std::cerr << "The next 3 failure messages are expected: " << std::endl;
+  assertion_exception_log();
+  assertion_text_log();
+  fixme_log();
+  std::cerr << "End of expected error messages" << std::endl;
+}
+#undef LEMON_ASSERT_LOG
 
 #define LEMON_ASSERT_CUSTOM
@@ -63 +207 @@
 }
 
+void my_assert_handler(const char*, int, const char*, 
+                       const std::exception&, const char*) {
+  ++cnt;
+}
+
+void my_assert_handler(const char*, int, const char*, 
+                       const std::string&, const char*) {
+  ++cnt;
+}
+
+
 #define LEMON_CUSTOM_ASSERT_HANDLER my_assert_handler
 #include <lemon/assert.h>
@@ -70 +225 @@
 }
 
+void no_assertion_exception_custom() {
+  LEMON_ASSERT(true, Exception());
+}
+
 void assertion_text_custom() {
   LEMON_ASSERT(false, "This is a fault message");
+}
+
+void assertion_exception_custom() {
+  LEMON_ASSERT(false, Exception());
 }
 
@@ -80 +243 @@
 void check_assertion_custom() {
   no_assertion_text_custom();
+  no_assertion_exception_custom();
+  assertion_exception_custom();
   assertion_text_custom();
   fixme_custom();
-  check(cnt == 2, "The custom assert handler does not work");
+  check(cnt == 3, "The custom assert handler does not work");
 }
 
@@ -90 +255 @@
 int main() {
   check_assertion_disable();
+  check_assertion_error();
+  check_assertion_exception();
+  check_assertion_log();
   check_assertion_custom();