multiPriorityQueue.h

Go to the documentation of this file.

#ifndef GUM_MULTI_PRIORITY_QUEUE_H
#define GUM_MULTI_PRIORITY_QUEUE_H

#include <functional>
#include <initializer_list>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include <agrum/agrum.h>
#include <agrum/core/hashTable.h>

namespace gum {

#define GUM_MULTIPLE_PRIORITY_QUEUE_DEFAULT_CAPACITY 10

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // templates provided by this file
  template < typename Val, typename Priority, typename Cmp, typename Alloc >
  class MultiPriorityQueue;

  template < typename Val, typename Priority, typename Cmp, typename Alloc >
  std::ostream& operator<<(std::ostream&,
                           const MultiPriorityQueue< Val, Priority, Cmp, Alloc >&);

#endif   // DOXYGEN_SHOULD_SKIP_THIS

  // ===========================================================================
  // ===                           PRIORITY QUEUES                           ===
  // ===========================================================================
  template < typename Val,
             typename Priority = int,
             typename Cmp = std::less< Priority >,
             typename Alloc = std::allocator< Val > >
  class MultiPriorityQueue {
    template < typename V, typename P, typename C, typename A >
    friend class MultiPriorityQueue;

    public:
    using value_type = Val;
    using reference = Val&;
    using const_reference = const Val&;
    using pointer = Val*;
    using const_pointer = const Val*;
    using difference_type = std::ptrdiff_t;
    using allocator_type = Alloc;

    using IndexAlloc = typename Alloc::template rebind<
       std::pair< Val, std::vector< Size > > >::other;

    using HeapAlloc =
       typename Alloc::template rebind< std::pair< Priority, const Val* > >::other;

    // ============================================================================
    // ============================================================================

    explicit MultiPriorityQueue(
       Cmp  compare = Cmp(),
       Size capacity = GUM_MULTIPLE_PRIORITY_QUEUE_DEFAULT_CAPACITY);

    explicit MultiPriorityQueue(
       std::initializer_list< std::pair< Val, Priority > > list);

    MultiPriorityQueue(
       const MultiPriorityQueue< Val, Priority, Cmp, Alloc >& from);


    template < typename OtherAlloc >
    MultiPriorityQueue(
       const MultiPriorityQueue< Val, Priority, Cmp, OtherAlloc >& from);

    MultiPriorityQueue(MultiPriorityQueue< Val, Priority, Cmp, Alloc >&& from);

    ~MultiPriorityQueue();

    // ============================================================================
    // ============================================================================

    MultiPriorityQueue< Val, Priority, Cmp, Alloc >&
       operator=(const MultiPriorityQueue< Val, Priority, Cmp, Alloc >& from);

    template < typename OtherAlloc >
    MultiPriorityQueue< Val, Priority, Cmp, Alloc >&
       operator=(const MultiPriorityQueue< Val, Priority, Cmp, OtherAlloc >& from);

    MultiPriorityQueue< Val, Priority, Cmp, Alloc >&
       operator=(MultiPriorityQueue< Val, Priority, Cmp, Alloc >&& from);

    const Val& operator[](Size index_elt) const;

    // ============================================================================
    // ============================================================================

    Size size() const noexcept;

    bool empty() const noexcept;

    bool contains(const Val& val) const;

    const Val& top() const;

    const Priority& topPriority() const;

    Val pop();

    Size insert(const Val& val, const Priority& priority);

    Size insert(Val&& val, Priority&& priority);

    template < typename... Args >
    Size emplace(Args&&... args);

    void eraseTop();

    void eraseByPos(Size index);

    void erase(const Val& val);

    Size setPriorityByPos(Size index, const Priority& new_priority);

    Size setPriorityByPos(Size index, Priority&& new_priority);

    void setPriority(const Val& elt, const Priority& new_priority);

    const Priority& priority(const Val& elt) const;

    void clear();

    const HashTable< Val, std::vector< Size > >& allValues() const;

    std::string toString() const;

    // ============================================================================
    // ============================================================================

    Size capacity() const noexcept;

    void resize(Size new_size);


    private:
    std::vector< std::pair< Priority, const Val* >, HeapAlloc > __heap;

    HashTable< Val, std::vector< Size >, IndexAlloc > __indices;

    Size __nb_elements{0};

    Cmp __cmp;
  };

} /* namespace gum */


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
#  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
extern template class gum::MultiPriorityQueue< std::string >;
#  endif
#endif
#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
#  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
extern template class gum::MultiPriorityQueue< int, int >;
#  endif
#endif


// always include the implementation of the templates
#include <agrum/core/multiPriorityQueue_tpl.h>

#endif /* GUM_MULTI_PRIORITY_QUEUE_H */