RhodeCode

  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::abort();

  }

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

				const char *function, const char* message,

				const char *assertion)

  {

    std::abort();

  }

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

				const char *function, 

				const std::string& message,

				const char *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)

  {

  }

  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)

  {

  }

/// @}

}

#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

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

#  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

///

///

///

/// \code

/// #define LEMON_ENABLE_ASSERTS

/// \endcode

/// or with compilation parameters:

/// \code

/// g++ -DLEMON_ENABLE_ASSERTS

/// make CXXFLAGS='-DLEMON_ENABLE_ASSERTS'

/// \endcode

/// 

///

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

///

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

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

///   \code

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

///

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

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

#ifndef LEMON_CONCEPT_HEAP_H

#define LEMON_CONCEPT_HEAP_H

#include <lemon/bits/invalid.h>

namespace lemon {

  namespace concepts {

    /// \addtogroup concept

    /// @{

    ///

    class Heap {

    public:

      ///

      ///

      enum State {

	IN_HEAP = 0,

	PRE_HEAP = -1,

	POST_HEAP = -2

      };

      /// \brief The constructor.

      ///

      /// The constructor.

      /// \brief The number of items stored in the heap.

      ///

      /// Returns the number of items stored in the heap.

      int size() const { return 0; }

      ///

      bool empty() const { return false; }

      ///

      void clear();

      ///    

      /// \param i The item to insert.

      /// \param p The priority of the item.

      void push(const Item &i, const Prio &p) {}

      ///

      Item top() const {}

      ///

      Prio prio() const {}

      ///

      void pop() {}

      ///

      void erase(const Item &i) {}

      ///

      /// \pre \c i must be in the heap.

      /// \param i The item.

      Prio operator[](const Item &i) const {}

      ///

      /// \param i The item.

      /// \param p The priority.

      void set(const Item &i, const Prio &p) {}

      ///

      /// \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) {}

      ///

      /// \param i The item.

      /// \param p The priority.

      void increase(const Item &i, const Prio &p) {}

      /// never been in the heap.

      ///

      /// \param i The item.

      State state(const Item &i) const {}

      ///

      /// better time complexity.

      /// \param i The item.

      void state(const Item& i, State st) {}

      template <typename _Heap>

      struct Constraints {

      public:

	void constraints() {

	  Item item;

	  Prio prio;

	  item=Item();

	  prio=Prio();

	  ignore_unused_variable_warning(item);

	  ignore_unused_variable_warning(prio);

	  ignore_unused_variable_warning(heap1);

	  prio = heap.prio();

	  item = heap.top();

	  heap.pop();

	  heap.set(item, prio);

	  heap.decrease(item, prio);

	  heap.increase(item, prio);

	  heap.erase(item);

	  state = heap.state(item);

	  state = _Heap::PRE_HEAP;

	  state = _Heap::IN_HEAP;

	  state = _Heap::POST_HEAP;

	_Heap& heap;

	ItemIntMap& map;

      };

    };

    /// @}

  } // namespace lemon

}

#endif // LEMON_CONCEPT_PATH_H

 * 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

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

      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;

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