LEMON/LEMON-main Changeset - r115:7b44eea654d0

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r115:7b44eea654d0

« 114:c837d1
« 111:e47fb2

128:7cd965 »
116:b6bede »

r115:7b44eea654d0

Tue, 01 Apr 2008 17:25:51

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Merge

0 3 0

merge default

0 files changed with 156 insertions and 143 deletions:

lemon/assert.h

lemon/concepts/heap.h

103

lemon/concepts/maps.h

↑ Collapse diff ↑

lemon/assert.h

Show inline comments

@@ -70,295 +70,283 @@
 			_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;
+		    assert_fail_log(file, line, function, exception, assertion);
 		    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;
+		    assert_fail_log(file, line, function, message, assertion);
 		    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);
+		    assert_fail_log(file, line, function, message.c_str(), assertion);
 		    std::abort();
+		  }
 		  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);
+		    throw AssertionFailedError(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);
+		    throw AssertionFailedError(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"
+		#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_ENABLE_ASSERTS)) &&			\
 		  defined(LEMON_DISABLE_ASSERTS)
-		#error "Lemon assertion system is not set properly"
+		#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
+		/// \brief Macro for assertion 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.
+		/// Macro for assertion with customizable message.
 		/// \param exp An expression that must be convertible to \c bool.
 		/// If it is \c false, then an assertion is raised. The concrete
 		/// behaviour depends on the settings of the assertion system.
 		/// \param msg A <tt>const char*</tt>, a <tt>const std::string&</tt> or
 		/// a <tt>const std::exception&</tt> parameter, which can be used to
 		/// provide information about the circumstances of the failed assertion.
 		///
 		/// The assertions are disabled in the default behaviour. You can
 		/// enable the assertions with the following code:
 		/// The assertions are disabled in the default behaviour.
 		/// You can enable them 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 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 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
 		/// - \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 LEMON_ASSERT_LOG, but it aborts the program. It is the default
 		///   behaviour mode when the assertions are enabled with
 		///   \c LEMON_ENABLE_ASSERTS.
 		/// - \c LEMON_ASSERT_ERROR The assertion 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.
 		/// - \c 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:
 		///   the given parameters.
 		/// - \c LEMON_ASSERT_CUSTOM The user can define 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);
 		///     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 std::string& message, const char* assertion);
 		///     void custom_assert_handler(const char* file, int line, const char* function,
 		///                                const std::exception& message, const char* assertion);
 		///   \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.
+		///   handlers 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.
 		/// 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.
 		#  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_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

lemon/concepts/heap.h

Show inline comments

 		/* -*- 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.
+		 *
 		 */
 		///\ingroup concept
 		///\file
 		///\brief Classes for representing heaps.
 		///
 		///\brief The concept of heaps.
 		#ifndef LEMON_CONCEPT_HEAP_H
 		#define LEMON_CONCEPT_HEAP_H
 		#include <lemon/bits/invalid.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// \brief A concept structure describes the main interface of heaps.
 		    /// \brief The heap concept.
 		    ///
 		    /// A concept structure describes the main interface of heaps.
 		    ///
-		    template <typename Prio, typename ItemIntMap>
+		    /// Concept class describing the main interface of heaps.
 		    template <typename Priority, typename ItemIntMap>
 		    class Heap {
 		    public:
 		      ///\brief Type of the items stored in the heap.
 		      typedef typename ItemIntMap::Key  Item;
+		      /// Type of the items stored in the heap.
 		      typedef typename ItemIntMap::Key Item;
-		      /// \brief Type to represent the items states.
+		      /// Type of the priorities.
 		      typedef Priority Prio;
 		      /// \brief Type to represent the states of the items.
 		      ///
 		      /// 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.
+		      /// 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 ItemIntMap _should_ be initialized in such way, that it maps
 		      /// PRE_HEAP (-1) to any element to be put in the heap...
 		      /// The \c ItemIntMap must be initialized in such a way, that it
 		      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
 		      enum State {
 			IN_HEAP = 0,
 			PRE_HEAP = -1,
 			POST_HEAP = -2
 		      };
 		      /// \brief The constructor.
 		      ///
 		      /// The constructor.
 		      /// \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) {}
 		      /// \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) {}
 		      /// \brief The number of items stored in the heap.
 		      ///
 		      /// Returns the number of items stored in the heap.
 		      int size() const { return 0; }
-		      /// \brief Checks if the heap stores no items.
+		      /// \brief Checks if the heap is empty.
 		      ///
-		      /// Returns \c true if and only if the heap stores no items.
+		      /// Returns \c true if the heap is empty.
 		      bool empty() const { return false; }
-		      /// \brief Makes empty this heap.
+		      /// \brief Makes the heap empty.
 		      ///
-		      /// Makes this heap empty.
+		      /// Makes the heap empty.
 		      void clear();
-		      /// \brief Insert an item into the heap with the given heap.
+		      /// \brief Inserts an item into the heap with the given priority.
 		      ///
-		      /// Adds \c i to the heap with priority \c p.
+		      /// Inserts the given item into the heap with the given priority.
 		      /// \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 with minimum priority.
+		      /// \brief Returns the item having minimum priority.
 		      ///
 		      /// This method returns the item with minimum priority.
 		      /// \pre The heap must be nonempty.
 		      /// Returns the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Item top() const {}
-		      /// \brief Returns the minimum priority.
+		      /// \brief The minimum priority.
 		      ///
 		      /// It returns the minimum priority.
 		      /// \pre The heap must be nonempty.
 		      /// Returns the minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Prio prio() const {}
-		      /// \brief Deletes the item with minimum priority.
+		      /// \brief Removes the item having minimum priority.
 		      ///
 		      /// This method deletes the item with minimum priority.
 		      /// \pre The heap must be non-empty.
 		      /// Removes the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      void pop() {}
-		      /// \brief Deletes \c i from the heap.
+		      /// \brief Removes an item 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.
+		      /// Removes the given item from the heap if it is already stored.
 		      /// \param i The item to delete.
 		      void erase(const Item &i) {}
-		      /// \brief Returns the priority of \c i.
+		      /// \brief The priority of an item.
 		      ///
-		      /// This function returns the priority of item \c i.
+		      /// Returns the priority of the given item.
 		      /// \pre \c i must be in the heap.
 		      /// \param i The item.
 		      Prio operator[](const Item &i) const {}
 		      /// \brief \c i gets to the heap with priority \c p independently
 		      /// if \c i was already there.
 		      /// \brief Sets the priority of an item or inserts it, if it is
 		      /// not stored in the heap.
 		      ///
 		      /// 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.
+		      /// 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.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void set(const Item &i, const Prio &p) {}
-		      /// \brief Decreases the priority of \c i to \c p.
+		      /// \brief Decreases the priority of an item to the given value.
 		      ///
-		      /// This method decreases the priority of item \c i to \c p.
+		      /// Decreases the priority of an item to the given value.
 		      /// \pre \c i must be stored in the heap with priority at least \c p.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void decrease(const Item &i, const Prio &p) {}
-		      /// \brief Increases the priority of \c i to \c p.
+		      /// \brief Increases the priority of an item to the given value.
 		      ///
 		      /// 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.
+		      /// 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.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void increase(const Item &i, const Prio &p) {}
-		      /// \brief Returns if \c item is in, has already been in, or has
+		      /// \brief Returns if an item is in, has already been in, or has
 		      /// never been in the heap.
 		      ///
 		      /// 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.
 		      /// 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.
 		      /// \param i The item.
 		      State state(const Item &i) const {}
-		      /// \brief Sets the state of the \c item in the heap.
+		      /// \brief Sets the state of an 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
 		      /// 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
 		      /// 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) {}
 		      template <typename _Heap>
 		      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);
 			  ignore_unused_variable_warning(state);
 			  typedef typename _Heap::State State;
 			  State 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);
 			  ignore_unused_variable_warning(state);
 			  _Heap heap1 = _Heap(map);
 			  _Heap heap1(map);
 			  _Heap heap2 = heap1;
 			  ignore_unused_variable_warning(heap1);
 			  heap.push(item, prio);
 			  ignore_unused_variable_warning(heap2);
 			  int s = heap.size();
 			  bool e = heap.empty();
 			  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();
 			  heap.set(item, prio);
 			  heap.decrease(item, prio);
 			  heap.increase(item, prio);
-			  prio = heap[item];
+			  heap.set(own_item, own_prio);
 			  heap.decrease(own_item, own_prio);
 			  heap.increase(own_item, own_prio);
 			  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) {}
 		      };
 		    };
 		    /// @}
 		  } // namespace lemon
+		}
 		#endif // LEMON_CONCEPT_PATH_H

lemon/concepts/maps.h

Show inline comments

 		/* -*- 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_CONCEPT_MAPS_H
 		#define LEMON_CONCEPT_MAPS_H
 		#include <lemon/bits/utility.h>
 		#include <lemon/concept_check.h>
 		///\ingroup concept
 		///\file
-		///\brief Map concepts checking classes for testing and documenting.
+		///\brief The concept of maps.
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// Readable map concept
 		    /// Readable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class ReadMap
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map. (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      template<typename _ReadMap>
 		      struct Constraints {
 			void constraints() {
 			  Value val = m[key];
 			  val = m[key];
 			  typename _ReadMap::Value own_val = m[own_key];
 			  own_val = m[own_key];
 			  ignore_unused_variable_warning(key);
 			  ignore_unused_variable_warning(val);
 			  ignore_unused_variable_warning(own_key);
 			  ignore_unused_variable_warning(own_val);
+			}
 			const Key& key;
 			const typename _ReadMap::Key& own_key;
 			const _ReadMap& m;
 		      };
 		    };
 		    /// Writable map concept
 		    /// Writable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class WriteMap
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map. (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Sets the value associated with the given key.
 		      void set(const Key &, const Value &) {}
 		      /// Default constructor.
 		      WriteMap() {}
 		      template <typename _WriteMap>
 		      struct Constraints {
 			void constraints() {
 			  m.set(key, val);
 			  m.set(own_key, own_val);
 			  ignore_unused_variable_warning(key);
 			  ignore_unused_variable_warning(val);
 			  ignore_unused_variable_warning(own_key);
 			  ignore_unused_variable_warning(own_val);
+			}
 			const Key& key;
 			const Value& val;
 			const typename _WriteMap::Key& own_key;
 			const typename _WriteMap::Value own_val;
+			const typename _WriteMap::Value& own_val;
 			_WriteMap& m;
 		      };
 		    };
 		    /// Read/writable map concept
 		    /// Read/writable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class ReadWriteMap : public ReadMap<K,T>,
 					 public WriteMap<K,T>
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map. (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      /// Sets the value associated with the given key.
 		      void set(const Key &, const Value &) {}
 		      template<typename _ReadWriteMap>
 		      struct Constraints {
 			void constraints() {
 			  checkConcept<ReadMap<K, T>, _ReadWriteMap >();
 			  checkConcept<WriteMap<K, T>, _ReadWriteMap >();
+			}
 		      };
 		    };
 		    /// Dereferable map concept
 		    /// Dereferable map concept.
 		    ///
 		    template<typename K, typename T, typename R, typename CR>
 		    class ReferenceMap : public ReadWriteMap<K,T>
+		    {
 		    public:
 		      /// Tag for reference maps.
 		      typedef True ReferenceMapTag;
 		      /// The key type of the map.
 		      typedef K Key;

0 comments (0 inline)

RhodeCode

Login to your account