priorityQueue.h

Go to the documentation of this file.

#ifndef GUM_PRIORITY_QUEUE_H
#define GUM_PRIORITY_QUEUE_H

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

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

namespace gum {

#define GUM_PRIORITY_QUEUE_DEFAULT_CAPACITY 10

  // templates provided by this file
  template < typename Val, typename Priority, typename Cmp, typename Alloc >
  class PriorityQueue;
  template < typename Val, typename Priority, typename Cmp, typename Alloc >
  std::ostream& operator<<(std::ostream&,
                           const PriorityQueue< Val, Priority, Cmp, Alloc >&);

  // ===========================================================================
  // ===              GENERAL IMPLEMENTATION OF PRIORITY QUEUES              ===
  // ===========================================================================

  template < typename Val,
             typename Priority,
             typename Cmp,
             typename Alloc,
             bool Gen >
  class PriorityQueueImplementation {
    friend class PriorityQueue< Val, Priority, Cmp, Alloc >;

    template < typename V, typename P, typename C, typename A, bool g >
    friend class PriorityQueueImplementation;

    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;

    // The allocator for the indices.
    using IndexAllocator =
       typename Alloc::template rebind< std::pair< Val, Size > >::other;

    // The allocator for the heap.
    using HeapAllocator =
       typename Alloc::template rebind< std::pair< Priority, const Val* > >::other;

    private:
    // ============================================================================
    // ============================================================================

    explicit PriorityQueueImplementation(Cmp compare, Size capacity);

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

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

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

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

    ~PriorityQueueImplementation();


    public:
    // ============================================================================
    // ============================================================================

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

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

    PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >& operator=(
       PriorityQueueImplementation< Val, Priority, Cmp, Alloc, Gen >&& 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);

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

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

    const Priority& priorityByPos(Size index) const;

    void clear();

    const HashTable< Val, Size >& allValues() const noexcept;

    std::string toString() const;

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

    Size capacity() const noexcept;

    void resize(Size new_size);


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

    HashTable< Val, Size, IndexAllocator > __indices{
       HashTableConst::default_size, true, true};

    Size __nb_elements{0};

    Cmp __cmp;
  };

#ifndef DOXYGEN_SHOULD_SKIP_THIS

  // ===========================================================================
  // ===              SCALAR IMPLEMENTATION OF PRIORITY QUEUES               ===
  // ===========================================================================

  template < typename Val, typename Priority, typename Cmp, typename Alloc >
  class PriorityQueueImplementation< Val, Priority, Cmp, Alloc, true > {
    friend class PriorityQueue< Val, Priority, Cmp, Alloc >;

    template < typename V, typename P, typename C, typename A, bool g >
    friend class PriorityQueueImplementation;

    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;

    // The allocator for the indices.
    using IndexAllocator =
       typename Alloc::template rebind< std::pair< Val, Size > >::other;

    // The allocator for the heap.
    using HeapAllocator =
       typename Alloc::template rebind< std::pair< Priority, Val > >::other;

    private:
    // ============================================================================
    // ============================================================================

    explicit PriorityQueueImplementation(Cmp compare, Size capacity);

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

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

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

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

    ~PriorityQueueImplementation();


    public:
    // ============================================================================
    // ============================================================================

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

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

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

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

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

    Size size() const noexcept;

    bool empty() const noexcept;

    bool contains(Val val) const;


    const Val& top() const;

    const Priority& topPriority() const;

    Val pop();

    Size insert(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(Val val);

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

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

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

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

    const Priority& priority(Val elt) const;

    const Priority& priorityByPos(Size index) const;

    void clear();

    const HashTable< Val, Size >& allValues() const noexcept;

    std::string toString() const;

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

    Size capacity() const noexcept;

    void resize(Size new_size);


    private:
    std::vector< std::pair< Priority, Val >, HeapAllocator > __heap;

    HashTable< Val, Size, IndexAllocator > __indices{
       HashTableConst::default_size, true, true};

    Size __nb_elements{0};

    Cmp __cmp;
  };

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

  // ===========================================================================
  // ===                           PRIORITY QUEUES                           ===
  // ===========================================================================
  template < typename Val,
             typename Priority = int,
             typename Cmp = std::less< Priority >,
             typename Alloc = std::allocator< Val > >
  class PriorityQueue
      : public PriorityQueueImplementation< Val,
                                            Priority,
                                            Cmp,
                                            Alloc,
                                            std::is_scalar< Val >::value > {
    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 Implementation =
       PriorityQueueImplementation< Val,
                                    Priority,
                                    Cmp,
                                    Alloc,
                                    std::is_scalar< Val >::value >;

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

    explicit PriorityQueue(Cmp  compare = Cmp(),
                           Size capacity = GUM_PRIORITY_QUEUE_DEFAULT_CAPACITY);

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

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

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

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

    ~PriorityQueue();

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

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

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

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

  };

} /* namespace gum */

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

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

#endif /* GUM_PRIORITY_QUEUE_H */