RhodeCode

      ///

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

      explicit Heap(ItemIntMap &map) {}

      /// \brief Constructor.

      ///

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

      /// \param comp The function object used for comparing the priorities.

      explicit Heap(ItemIntMap &map, const CMP &comp) {}

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

      ///

      /// This function returns the number of items stored in the heap.

      int size() const { return 0; }

      ///

      /// This function inserts the given item into the heap with the

      /// given priority.

      /// \param i The item to insert.

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

      /// \pre \e i must not be stored in the heap.

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

      /// \brief Return the item having minimum priority.

      ///

      /// This function returns the item having minimum priority.

      /// \pre The heap must be non-empty.

      /// \brief The minimum priority.

      ///

      /// This function returns the minimum priority.

      /// \pre The heap must be non-empty.

      /// \brief Remove the item having minimum priority.

      ///

      /// This function removes the item having minimum priority.

      /// \pre The heap must be non-empty.

      void pop() {}

      /// \brief Remove the given item from the heap.

      ///

      /// This function removes the given item from the heap if it is

      /// already stored.

      /// \param i The item to delete.

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

      void erase(const Item &i) {}

      /// \brief The priority of the given item.

      ///

      /// This function returns the priority of the given item.

      /// \param i The item.

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

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

      /// \brief Set the priority of an item or insert 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 into the heap with the given priority.

      ///

      /// \param i The item.

      /// \param p The priority.

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

      /// \brief Decrease the priority of an item to the given value.

      ///

      /// This function decreases the priority of an item to the given value.

      /// \param i The item.

      /// \param p The priority.

      /// \pre \e i must be stored in the heap with priority at least \e p.

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

      /// \brief Increase the priority of an item to the given value.

      ///

      /// This function increases the priority of an item to the given value.

      /// \param i The item.

      /// \param p The priority.

      /// \pre \e i must be stored in the heap with priority at most \e p.

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

      /// \brief Return the state of an item.

      ///

      /// 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 Set the state of an item in the heap.

      ///

      /// This function 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 better time complexity.

      /// \param i The item.

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