gum::PriorityQueue< Val, Priority, Cmp, Alloc > Class Template Reference

A priorityQueue is a heap in which each element has a mutable priorityA priority queue is quite similar to a heap except that a priority (a score) is assigned to each element in the structure. More...

#include <agrum/tools/core/priorityQueue.h>

Inheritance diagram for gum::PriorityQueue< Val, Priority, Cmp, Alloc >:

Collaboration diagram for gum::PriorityQueue< Val, Priority, Cmp, Alloc >:

Public Member Functions
template<typename OtherAlloc >
INLINE	PriorityQueue (const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &from)
template<typename OtherAlloc >
INLINE PriorityQueue< Val, Priority, Cmp, Alloc > &	operator= (const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &from)
INLINE Size	emplace (Args &&... args)
Constructors / Destructors
	PriorityQueue (Cmp compare=Cmp(), Size capacity=GUM_PRIORITY_QUEUE_DEFAULT_CAPACITY)
	Basic constructor. More...
	PriorityQueue (std::initializer_list< std::pair< Val, Priority > > list)
	Initializer list constructor. More...
	PriorityQueue (const PriorityQueue< Val, Priority, Cmp, Alloc > &from)
	Copy constructor. More...
template<typename OtherAlloc >
	PriorityQueue (const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &from)
	Generalized copy constructor. More...
	PriorityQueue (PriorityQueue< Val, Priority, Cmp, Alloc > &&from)
	Move constructor. More...
	~PriorityQueue ()
	Class destructor. More...
Operators
PriorityQueue< Val, Priority, Cmp, Alloc > &	operator= (const PriorityQueue< Val, Priority, Cmp, Alloc > &from)
	Copy operator. More...
template<typename OtherAlloc >
PriorityQueue< Val, Priority, Cmp, Alloc > &	operator= (const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &from)
	Generalized opy operator. More...
PriorityQueue< Val, Priority, Cmp, Alloc > &	operator= (PriorityQueue< Val, Priority, Cmp, Alloc > &&from)
	Move operator. More...
Operators
const Val &	operator[] (Size index_elt) const
	Returns the element at index "index_elt" from the priority queue. More...
Accessors / Modifiers
Size	size () const noexcept
	Returns the number of elements in the priority queue. More...
bool	empty () const noexcept
	Indicates whether the priority queue is empty. More...
bool	contains (const Val &val) const
	Indicates whether the priority queue contains a given value. More...
const Val &	top () const
	returns the element at the top of the priority queue More...
const Priority &	topPriority () const
	Returns the priority of the top element. More...
Val	pop ()
	Removes the top element from the priority queue and return it. More...
Size	insert (const Val &val, const Priority &priority)
	Inserts a new (a copy) element in the priority queue. More...
Size	insert (Val &&val, Priority &&priority)
	Inserts (by move) a new element in the priority queue. More...
Size	emplace (Args &&... args)
	Emplace a new element into the priority queue. More...
void	eraseTop ()
	Removes the top of the priority queue (but does not return it). More...
void	eraseByPos (Size index)
	Removes the element at position "index" from the priority queue. More...
void	erase (const Val &val)
	Removes a given element from the priority queue (but does not return it). More...
Size	setPriorityByPos (Size index, const Priority &new_priority)
	Modifies the priority of the element at position "index" of the queue. More...
Size	setPriorityByPos (Size index, Priority &&new_priority)
	Modifies the priority of the element at position "index" of the queue. More...
void	setPriority (const Val &elt, const Priority &new_priority)
	Modifies the priority of each instance of a given element. More...
void	setPriority (const Val &elt, Priority &&new_priority)
	Modifies the priority of each instance of a given element. More...
const Priority &	priority (const Val &elt) const
	Returns the priority of an instance of the value passed in argument. More...
const Priority &	priorityByPos (Size index) const
	Returns the priority of the value passed in argument. More...
void	clear ()
	Removes all the elements from the queue. More...
const HashTable< Val, Size > &	allValues () const noexcept
	Returns a hashtable the keys of which are the values stored in the queue. More...
std::string	toString () const
	Displays the content of the queue. More...
Fine tuning
Size	capacity () const noexcept
	Returns the size of the internal structure storing the priority queue. More...
void	resize (Size new_size)
	Changes the size of the internal structure storing the priority queue. More...

Public Types
using	Implementation = PriorityQueueImplementation< Val, Priority, Cmp, Alloc, std::is_scalar< Val >::value >
using	IndexAllocator = typename Alloc::template rebind< std::pair< Val, Size > >::other
using	HeapAllocator = typename Alloc::template rebind< std::pair< Priority, const Val * > >::other
using	value_type = Val
	Types for STL compliance. More...
using	reference = Val &
	Types for STL compliance. More...
using	const_reference = const Val &
	Types for STL compliance. More...
using	pointer = Val *
	Types for STL compliance. More...
using	const_pointer = const Val *
	Types for STL compliance. More...
using	difference_type = std::ptrdiff_t
	Types for STL compliance. More...
using	allocator_type = Alloc
	Types for STL compliance. More...

Detailed Description

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>
class gum::PriorityQueue< Val, Priority, Cmp, Alloc >

A priorityQueue is a heap in which each element has a mutable priority

A priority queue is quite similar to a heap except that a priority (a score) is assigned to each element in the structure.

The elements are sorted according to a weak order on the scores. The priority of any element can be changed at any moment by the user. The priority queue then restores a heap property accordingly. Duplicate elements are not allowed in priority queues; if you wish an element to appear several times with different priorities, prefer using class MultiplePriorityQueue.

Usage example:

// create a priority queue of strings, the priorities of which are integers
// the element at the top of the queue has the smallest priority
PriorityQueue<std::string> queue1;

// insert elements into the queue
queue1.insert ("AAA", 8);
queue1.insert ("BBB", 10);
queue1.insert ("CCC", 2);
queue1.insert ("DDD", 23);
queue1.insert ("EEE", 24);

// copy the queue
PriorityQueue<std::string> queue2 = queue1;

// initializer list constructor
PriorityQueue<std::string,int> queue3 { std::pair<std::string,int>("aa",3),
                                        std::pair<std::string,int>("bb",2)
};

// create a priority queue of strings, the priorities of which are
// pairs of ints
PriorityQueue< std::string, std::pair<int,int> > queue3;

// get the top element, then remove it
std::cerr << queue2.top() << std::endl;
queue2.eraseTop();

// get the top element, then remove it
std::cerr << queue2.pop() << std::endl;

// output the content of the queue
std::cerr << queue1 << std::endl;

// change the priority of the element at position 3
Size new_pos=queue1.setPriorityByPos (3,100);

// change the priority of all instances of element "AAA"
queue1.setPriority ("AAA",100);

Template Parameters

Val	The values type.
Priority	The priorities type.
Cmp	The priorities comparator.
Alloc	The values allocator.

Definition at line 50 of file priorityQueue.h.

Member Typedef Documentation

allocator_type

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::allocator_type = Alloc

Types for STL compliance.

Definition at line 958 of file priorityQueue.h.

const_pointer

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::const_pointer = const Val*

Types for STL compliance.

Definition at line 956 of file priorityQueue.h.

const_reference

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::const_reference = const Val&

Types for STL compliance.

Definition at line 954 of file priorityQueue.h.

difference_type

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::difference_type = std::ptrdiff_t

Types for STL compliance.

Definition at line 957 of file priorityQueue.h.

HeapAllocator

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >::HeapAllocator = typename Alloc::template rebind< std::pair< Priority, const Val* > >::other

inherited

Definition at line 104 of file priorityQueue.h.

Implementation

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::Implementation = PriorityQueueImplementation< Val, Priority, Cmp, Alloc, std::is_scalar< Val >::value >

Definition at line 962 of file priorityQueue.h.

IndexAllocator

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >::IndexAllocator = typename Alloc::template rebind< std::pair< Val, Size > >::other

inherited

Definition at line 100 of file priorityQueue.h.

pointer

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::pointer = Val*

Types for STL compliance.

Definition at line 955 of file priorityQueue.h.

reference

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::reference = Val&

Types for STL compliance.

Definition at line 953 of file priorityQueue.h.

value_type

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

using gum::PriorityQueue< Val, Priority, Cmp, Alloc >::value_type = Val

Types for STL compliance.

Definition at line 952 of file priorityQueue.h.

Constructor & Destructor Documentation

PriorityQueue() [1/6]

template<typename Val , typename Priority , typename Cmp, typename Alloc >

INLINE gum::PriorityQueue< Val, Priority, Cmp, Alloc >::PriorityQueue ( Cmp  compare = Cmp(), Size  capacity = GUM_PRIORITY_QUEUE_DEFAULT_CAPACITY  )

explicit

Basic constructor.

Creates an empty priority queue.

Parameters

compare	a function taking two elements in argument, say e1 and e2, and returning a Boolean indicating wether e1 < e2, i.e., whether e1 should be nearer than e2 to the top of the heap.
capacity	the size of the internal data structures containing the elements (could be for instance vectors or hashtables).

Definition at line 1098 of file priorityQueue_tpl.h.

                                                                                         :
      PriorityQueue< Val, Priority, Cmp, Alloc >::Implementation(cmp, capacity) {
    // for debugging purposes
    GUM_CONSTRUCTOR(PriorityQueue);
  }

PriorityQueue() [2/6]

template<typename Val, typename Priority, typename Cmp, typename Alloc >

INLINE gum::PriorityQueue< Val, Priority, Cmp, Alloc >::PriorityQueue ( std::initializer_list< std::pair< Val, Priority > >  list )

explicit

Initializer list constructor.

The elements of the initializer list are pairs <Val,Priority>. The comparison function is the default one, i.e., std::less<Priority>.

Parameters

list	The initializer list.

Definition at line 1106 of file priorityQueue_tpl.h.

                                                           :
      PriorityQueue< Val, Priority, Cmp, Alloc >::Implementation{list} {
    // for debugging purposes
    GUM_CONSTRUCTOR(PriorityQueue);
  }

PriorityQueue() [3/6]

template<typename Val, typename Priority, typename Cmp, typename Alloc>

INLINE gum::PriorityQueue< Val, Priority, Cmp, Alloc >::PriorityQueue

(

const PriorityQueue< Val, Priority, Cmp, Alloc > &

from

)

Copy constructor.

Parameters

from	The gum::PriorityQueue to copy.

Definition at line 1115 of file priorityQueue_tpl.h.

                                                             :
      PriorityQueue< Val, Priority, Cmp, Alloc >::Implementation(from) {
    // for debugging purposes
    GUM_CONS_CPY(PriorityQueue);
  }

PriorityQueue() [4/6]

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

template<typename OtherAlloc >

gum::PriorityQueue< Val, Priority, Cmp, Alloc >::PriorityQueue

(

const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &

from

)

Generalized copy constructor.

Parameters

from	The gum::PriorityQueue to copy.

PriorityQueue() [5/6]

template<typename Val, typename Priority, typename Cmp, typename Alloc>

INLINE gum::PriorityQueue< Val, Priority, Cmp, Alloc >::PriorityQueue

(

PriorityQueue< Val, Priority, Cmp, Alloc > &&

from

)

Move constructor.

Parameters

from	The gum::PriorityQueue to move.

Definition at line 1134 of file priorityQueue_tpl.h.

                                                        :
      PriorityQueue< Val, Priority, Cmp, Alloc >::Implementation(std::move(from)) {
    // for debugging purposes
    GUM_CONS_MOV(PriorityQueue);
  }

~PriorityQueue()

template<typename Val , typename Priority , typename Cmp , typename Alloc >

INLINE gum::PriorityQueue< Val, Priority, Cmp, Alloc >::~PriorityQueue

(

)

Class destructor.

Definition at line 1143 of file priorityQueue_tpl.h.

                                                                    {
    // for debugging purposes
    GUM_DESTRUCTOR(PriorityQueue);
  }

PriorityQueue() [6/6]

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

template<typename OtherAlloc >

INLINE gum::PriorityQueue< Val, Priority, Cmp, Alloc >::PriorityQueue

(

const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &

from

)

Definition at line 1125 of file priorityQueue_tpl.h.

                                                                  :
      PriorityQueue< Val, Priority, Cmp, Alloc >::Implementation(from) {
    // for debugging purposes
    GUM_CONS_CPY(PriorityQueue);
  }

Member Function Documentation

allValues()

INLINE const HashTable< Val, Size > & gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::allValues ( ) const

noexceptinherited

Returns a hashtable the keys of which are the values stored in the queue.

The keys of the hashtable correspond to the values stored in the priority queue and, for each key, the corresponding value is the index in the queue where we can find the key.

Returns

Returns a hashtable the keys of which are the values stored in the queue.

Definition at line 313 of file priorityQueue_tpl.h.

                                                                                             {
    return reinterpret_cast< const HashTable< Val, Size >& >(_indices_);
  }

capacity()

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::capacity ( ) const

noexceptinherited

Returns the size of the internal structure storing the priority queue.

Returns

Returns the size of the internal structure storing the priority queue.

Definition at line 229 of file priorityQueue_tpl.h.

                                                                                            {
    return Size(_heap_.capacity());
  }

clear()

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::clear ( )

inherited

Removes all the elements from the queue.

Definition at line 244 of file priorityQueue_tpl.h.

                                                                                   {
    _nb_elements_ = 0;
    _heap_.clear();
    _indices_.clear();
  }

contains()

INLINE bool gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::contains ( const Val &  val ) const

inherited

Indicates whether the priority queue contains a given value.

Parameters

val	The value to look for.

Returns

Returns true if val is in the priority queue.

Definition at line 410 of file priorityQueue_tpl.h.

                                                                                                 {
    return _indices_.exists(val);
  }

emplace() [1/2]

Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >::emplace ( Args &&...  args )

inherited

Emplace a new element into the priority queue.

See gum::PriorityQueueImplementation::eraseByPos(Size) for more details about the index.

Template Parameters

Args	The emplace arguments types.

Parameters

args	The emplace arguments.

Returns

Returns the index of the element inserted into the priority queue.

Exceptions

DuplicateElement

Raised if the element already exists.

emplace() [2/2]

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::emplace ( Args &&...  args )

inherited

Definition at line 394 of file priorityQueue_tpl.h.

                                                                                          {
    std::pair< Val, Priority > new_elt
       = std::make_pair< Val, Priority >(std::forward< Args >(args)...);
    return insert(std::move(new_elt.first), std::move(new_elt.second));
  }

empty()

INLINE bool gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::empty ( ) const

noexceptinherited

Indicates whether the priority queue is empty.

Returns

Returns true if the priority queue is empty.

Definition at line 403 of file priorityQueue_tpl.h.

                                                                                         {
    return (_nb_elements_ == 0);
  }

erase()

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::erase ( const Val &  val )

inherited

Removes a given element from the priority queue (but does not return it).

If the element cannot be found, the function returns without throwing any exception.

If the queue contains several times this element, then the one with the smallest index is removed.

Parameters

val	the element we wish to remove.

Definition at line 287 of file priorityQueue_tpl.h.

                                                                                                 {
    try {
      eraseByPos(_indices_[val]);
    } catch (NotFound&) {}
  }

eraseByPos()

void gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::eraseByPos ( Size  index )

inherited

Removes the element at position "index" from the priority queue.

If the element cannot be found, the function returns without throwing any exception.

The priority is computed as follows: suppose that the queue is a complete binary tree where all levels are completely filled except, eventually, the last one. In this case, the elements of the last level are all on the left of the tree.

We assign 0 to the root, then parsing the tree from top to bottom then from left to right we increment the index and assigned it to the current node. Doing so, we get a unique index for each element. This is precisely what the index passed in argument of the function represents.

Parameters

index

represents the position of the element to be removed.

Definition at line 252 of file priorityQueue_tpl.h.

                                                                                           {
    if (index >= _nb_elements_) return;

    // remove the element from the hashtable
    _indices_.erase(*(_heap_[index].second));

    // put the last element at the "index" location
    std::pair< Priority, const Val* > last = std::move(_heap_[_nb_elements_ - 1]);
    _heap_.pop_back();
    --_nb_elements_;

    if (!_nb_elements_ || (index == _nb_elements_)) return;

    // restore the heap property
    Size i = index;

    for (Size j = (index << 1) + 1; j < _nb_elements_; i = j, j = (j << 1) + 1) {
      // let j be the max child
      if ((j + 1 < _nb_elements_) && _cmp_(_heap_[j + 1].first, _heap_[j].first)) ++j;

      // if "last" is lower than heap[j], "last" must be stored at index i
      if (_cmp_(last.first, _heap_[j].first)) break;

      // else pull up the jth node
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }

    // put "last" back into the heap
    _heap_[i]                      = std::move(last);
    _indices_[*(_heap_[i].second)] = i;
  }

eraseTop()

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::eraseTop ( )

inherited

Removes the top of the priority queue (but does not return it).

If the heap is empty, it does nothing (in particular, it does not throw any exception).

Definition at line 295 of file priorityQueue_tpl.h.

                                                                                      {
    eraseByPos(0);
  }

insert() [1/2]

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >::insert ( const Val &  val, const Priority &  priority  )

inherited

Inserts a new (a copy) element in the priority queue.

See gum::PriorityQueueImplementation::eraseByPos(Size) for more details about the index.

Parameters

val	The value to insert.
priority	The value's priority in the queue.

Returns

Returns the index of the element inserted into the priority queue.

Exceptions

DuplicateElement

Raised if the element already exists.

Definition at line 319 of file priorityQueue_tpl.h.

                               {
    // create the entry in the indices hashtable (if the element already exists,
    //  _indices_.insert will raise a Duplicateelement exception)
    typename HashTable< Val, Size, IndexAllocator >::value_type& new_elt = _indices_.insert(val, 0);

    try {
      _heap_.push_back(std::pair< Priority, const Val* >(priority, &new_elt.first));
    } catch (...) {
      _indices_.erase(val);
      throw;
    }

    std::pair< Priority, const Val* > new_heap_val = std::move(_heap_[_nb_elements_]);
    ++_nb_elements_;

    // restore the heap property
    Size i = _nb_elements_ - 1;

    for (Size j = (i - 1) >> 1; i && _cmp_(new_heap_val.first, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }

    // put the new bucket into the heap
    _heap_[i].first  = std::move(new_heap_val.first);
    _heap_[i].second = &(new_elt.first);
    new_elt.second   = i;

    return i;
  }

insert() [2/2]

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >::insert ( Val &&  val, Priority &&  priority  )

inherited

Inserts (by move) a new element in the priority queue.

See gum::PriorityQueueImplementation::eraseByPos(Size) for more details about the index.

Parameters

val	The value to insert.
priority	The value's priority in the queue.

Returns

Returns the index of the element inserted into the priority queue.

Exceptions

DuplicateElement

Raised if the element already exists.

Definition at line 356 of file priorityQueue_tpl.h.

                                                                                                {
    // create the entry in the indices hashtable (if the element already exists,
    //  _indices_.insert will raise a Duplicateelement exception)
    typename HashTable< Val, Size, IndexAllocator >::value_type& new_elt
       = _indices_.insert(std::move(val), 0);

    try {
      _heap_.push_back(std::pair< Priority, const Val* >(std::move(priority), &(new_elt.first)));
    } catch (...) {
      _indices_.erase(new_elt.first);
      throw;
    }

    std::pair< Priority, const Val* > new_heap_val = std::move(_heap_[_nb_elements_]);
    ++_nb_elements_;

    // restore the heap property
    Size i = _nb_elements_ - 1;

    for (Size j = (i - 1) >> 1; i && _cmp_(new_heap_val.first, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }

    // put the new bucket into the heap
    _heap_[i].first  = std::move(new_heap_val.first);
    _heap_[i].second = &(new_elt.first);
    new_elt.second   = i;

    return i;
  }

operator=() [1/4]

template<typename Val, typename Priority, typename Cmp, typename Alloc>

INLINE PriorityQueue< Val, Priority, Cmp, Alloc > & gum::PriorityQueue< Val, Priority, Cmp, Alloc >::operator=

(

const PriorityQueue< Val, Priority, Cmp, Alloc > &

from

)

Copy operator.

When a problem occurs during the copy (for instance when not enough memory is available), the operator guarantees that the heap stays in a coherent state. Actually, the priority queue becomes empty. An exception is then thrown.

Parameters

from	The gum::PriorityQueue to copy.

Returns

Returns this gum::PriorityQueue.

Definition at line 1151 of file priorityQueue_tpl.h.

                                                                {
    Implementation::operator=(from);
    return *this;
  }

operator=() [2/4]

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

template<typename OtherAlloc >

PriorityQueue< Val, Priority, Cmp, Alloc >& gum::PriorityQueue< Val, Priority, Cmp, Alloc >::operator=

(

const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &

from

)

Generalized opy operator.

When a problem occurs during the copy (for instance when not enough memory is available), the operator guarantees that the heap stays in a coherent state. Actually, the priority queue becomes empty. An exception is then thrown.

Parameters

from	The gum::PriorityQueue to copy.

Returns

Returns this gum::PriorityQueue.

operator=() [3/4]

template<typename Val, typename Priority, typename Cmp, typename Alloc>

INLINE PriorityQueue< Val, Priority, Cmp, Alloc > & gum::PriorityQueue< Val, Priority, Cmp, Alloc >::operator=

(

PriorityQueue< Val, Priority, Cmp, Alloc > &&

from

)

Move operator.

Parameters

from	The gum::PriorityQueue to move.

Returns

Returns this gum::PriorityQueue.

Definition at line 1170 of file priorityQueue_tpl.h.

                                                           {
    Implementation::operator=(std::move(from));
    return *this;
  }

operator=() [4/4]

template<typename Val, typename Priority = int, typename Cmp = std::less< Priority >, typename Alloc = std::allocator< Val >>

template<typename OtherAlloc >

INLINE PriorityQueue< Val, Priority, Cmp, Alloc >& gum::PriorityQueue< Val, Priority, Cmp, Alloc >::operator=

(

const PriorityQueue< Val, Priority, Cmp, OtherAlloc > &

from

)

Definition at line 1161 of file priorityQueue_tpl.h.

                                                                     {
    Implementation::operator=(from);
    return *this;
  }

operator[]()

INLINE const Val & gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::operator[] ( Size  index_elt ) const

inherited

Returns the element at index "index_elt" from the priority queue.

Parameters

index_elt

The index of the element to return.

Returns

Returns the element at index "index_elt" from the priority queue.

Exceptions

NotFound

Raised if the element does not exist.

Definition at line 417 of file priorityQueue_tpl.h.

                                                                                               {
    if (index >= _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }

    return *(_heap_[index].second);
  }

pop()

INLINE Val gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::pop ( )

inherited

Removes the top element from the priority queue and return it.

Returns

Returns the top element from the priority queue.

Exceptions

NotFound

Raised if the queue is empty.

Definition at line 301 of file priorityQueue_tpl.h.

                                                                                {
    if (!_nb_elements_) { GUM_ERROR(NotFound, "empty priority queue") }

    Val v = *(_heap_[0].second);
    eraseByPos(0);

    return v;
  }

priority()

INLINE const Priority & gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::priority ( const Val &  elt ) const

inherited

Returns the priority of an instance of the value passed in argument.

Parameters

elt	The element for which the priority is returned.

Returns

Returns the priority of an instance of the value passed in argument.

Exceptions

NotFound

Raised if the element cannot be found.

Definition at line 550 of file priorityQueue_tpl.h.

                                                                                                 {
    return _heap_[_indices_[elt]].first;
  }

priorityByPos()

INLINE const Priority & gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::priorityByPos ( Size  index ) const

inherited

Returns the priority of the value passed in argument.

Parameters

index

The index of the value of which the priority is returned.

Exceptions

NotFound

Raised if the element cannot be found.

Definition at line 557 of file priorityQueue_tpl.h.

                          {
    if (index > _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }
    return _heap_[index].first;
  }

resize()

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::resize ( Size  new_size )

inherited

Changes the size of the internal structure storing the priority queue.

Parameters

new_size

The internal structure new size.

Definition at line 235 of file priorityQueue_tpl.h.

                                                                                                 {
    if (new_size < _nb_elements_) return;

    _heap_.reserve(new_size);
    _indices_.resize(new_size / 2);
  }

setPriority() [1/2]

void gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >::setPriority ( const Val &  elt, const Priority &  new_priority  )

inherited

Modifies the priority of each instance of a given element.

Parameters

elt	The value to update.
new_priority	The values new priority.

Exceptions

NotFound

Raised if the element cannot be found.

Definition at line 533 of file priorityQueue_tpl.h.

                                   {
    setPriorityByPos(_indices_[elt], new_priority);
  }

setPriority() [2/2]

void gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >::setPriority ( const Val &  elt, Priority &&  new_priority  )

inherited

Modifies the priority of each instance of a given element.

Parameters

elt	The value to update.
new_priority	The values new priority.

Exceptions

NotFound

Raised if the element cannot be found.

Definition at line 541 of file priorityQueue_tpl.h.

                              {
    setPriorityByPos(_indices_[elt], std::move(new_priority));
  }

setPriorityByPos() [1/2]

Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::setPriorityByPos ( Size  index, const Priority &  new_priority  )

inherited

Modifies the priority of the element at position "index" of the queue.

Parameters

index	The index of the element to update.
new_priority	The element's new priority.

Returns

Returns the elements new priority.

Exceptions

NotFound

Raised if the element cannot be found.

Definition at line 445 of file priorityQueue_tpl.h.

                                   {
    // check whether the element the priority of which should be changed exists
    if (index >= _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }

    // get the element itself
    const Val* val = _heap_[index].second;

    // restore the heap property
    Size i = index;

    // move val upward if needed
    for (Size j = (i - 1) >> 1; i && _cmp_(new_priority, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }

    // move val downward if needed
    for (Size j = (i << 1) + 1; j < _nb_elements_; i = j, j = (j << 1) + 1) {
      // let j be the max child
      if ((j + 1 < _nb_elements_) && _cmp_(_heap_[j + 1].first, _heap_[j].first)) ++j;

      // if "val" is lower than heap[j], "val" must be stored at index i
      if (_cmp_(new_priority, _heap_[j].first)) break;

      // else pull up the jth node
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }

    // update the index of val
    _heap_[i].first  = new_priority;
    _heap_[i].second = val;
    _indices_[*val]  = i;

    return i;
  }

setPriorityByPos() [2/2]

Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::setPriorityByPos ( Size  index, Priority &&  new_priority  )

inherited

Modifies the priority of the element at position "index" of the queue.

Parameters

index	The index of the element to update.
new_priority	The element's new priority.

Returns

Returns the elements new priority.

Exceptions

NotFound

Raised if the element cannot be found.

Definition at line 489 of file priorityQueue_tpl.h.

                              {
    // check whether the element the priority of which should be changed exists
    if (index >= _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }

    // get the element itself
    const Val* val = _heap_[index].second;

    // restore the heap property
    Size i = index;

    // move val upward if needed
    for (Size j = (i - 1) >> 1; i && _cmp_(new_priority, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }

    // move val downward if needed
    for (Size j = (i << 1) + 1; j < _nb_elements_; i = j, j = (j << 1) + 1) {
      // let j be the max child
      if ((j + 1 < _nb_elements_) && _cmp_(_heap_[j + 1].first, _heap_[j].first)) ++j;

      // if "val" is lower than heap[j], "val" must be stored at index i
      if (_cmp_(new_priority, _heap_[j].first)) break;

      // else pull up the jth node
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }

    // update the index of val
    _heap_[i].first  = std::move(new_priority);
    _heap_[i].second = val;
    _indices_[*val]  = i;

    return i;
  }

size()

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::size ( ) const

noexceptinherited

Returns the number of elements in the priority queue.

Returns

Returns the number of elements in the priority queue.

Definition at line 222 of file priorityQueue_tpl.h.

                                                                                                 {
    return _nb_elements_;
  }

top()

INLINE const Val & gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::top ( ) const

inherited

returns the element at the top of the priority queue

Exceptions

NotFound

Raised if the queue is empty

Definition at line 205 of file priorityQueue_tpl.h.

                                                                                             {
    if (!_nb_elements_) { GUM_ERROR(NotFound, "empty priority queue") }

    return *(_heap_[0].second);
  }

topPriority()

INLINE const Priority & gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::topPriority ( ) const

inherited

Returns the priority of the top element.

Returns

Returns the priority of the top element.

Exceptions

NotFound

Raised if the queue is empty.

Definition at line 214 of file priorityQueue_tpl.h.

                                                                                                {
    if (!_nb_elements_) { GUM_ERROR(NotFound, "empty priority queue") }

    return _heap_[0].first;
  }

toString()

std::string gum::PriorityQueueImplementation< Val, Priority, Cmp, Alloc >::toString ( ) const

inherited

Displays the content of the queue.

Returns

Returns the content of the queue.

Definition at line 427 of file priorityQueue_tpl.h.

                                                                                          {
    bool              deja = false;
    std::stringstream stream;
    stream << "[";

    for (Size i = 0; i != _nb_elements_; ++i, deja = true) {
      if (deja) stream << " , ";

      stream << "(" << _heap_[i].first << " , " << *(_heap_[i].second) << ")";
    }

    stream << "]";

    return stream.str();
  }

---

The documentation for this class was generated from the following files:

• agrum/tools/core/priorityQueue.h
• agrum/tools/core/priorityQueue_tpl.h