limitedPriorityQueue.h

 
#pragma once
 
#include <cstddef>
#include <array>
#include <algorithm>
#include <functional>
 
#include "../defines.h"
#include "./iteratorUtils.h"
#include "../Assert.h"
#include "concepts.h"
 
namespace Ponca
{
 
    template <class T, int N, class CompareT = std::less<T>>
        requires ValidCapacity<N>
    class LimitedPriorityQueue
    {
    public:
        using value_type     = T;
        using container_type = std::array<T, N>;
        using compare        = CompareT;
        using iterator       = typename container_type::iterator;
        using const_iterator = typename container_type::const_iterator;
        using Self           = LimitedPriorityQueue<T, N, CompareT>;
 
        // LimitedPriorityQueue --------------------------------------------------
    public:
        PONCA_MULTIARCH inline LimitedPriorityQueue();
        PONCA_MULTIARCH inline LimitedPriorityQueue(const Self& other);
        PONCA_MULTIARCH inline explicit LimitedPriorityQueue(int capacity);
        template <class InputIt>
        PONCA_MULTIARCH LimitedPriorityQueue(int capacity, InputIt first, InputIt last);
 
        PONCA_MULTIARCH inline ~LimitedPriorityQueue() = default;
 
        PONCA_MULTIARCH inline LimitedPriorityQueue& operator=(const Self& other) = default;
 
        // Iterator ----------------------------------------------------------------
    public:
        PONCA_MULTIARCH [[nodiscard]] inline iterator begin();
        PONCA_MULTIARCH [[nodiscard]] inline const_iterator begin() const;
        PONCA_MULTIARCH [[nodiscard]] inline const_iterator cbegin() const;
 
        PONCA_MULTIARCH [[nodiscard]] inline iterator end();
        PONCA_MULTIARCH [[nodiscard]] inline const_iterator end() const;
        PONCA_MULTIARCH [[nodiscard]] inline const_iterator cend() const;
 
        // Element access ----------------------------------------------------------
    public:
        PONCA_MULTIARCH [[nodiscard]] inline const T& top() const;
        PONCA_MULTIARCH [[nodiscard]] inline const T& bottom() const;
 
        PONCA_MULTIARCH [[nodiscard]] inline T& top();
        PONCA_MULTIARCH [[nodiscard]] inline T& bottom();
 
        // Capacity ----------------------------------------------------------------
    public:
        PONCA_MULTIARCH [[nodiscard]] inline bool empty() const;
        PONCA_MULTIARCH [[nodiscard]] inline bool full() const;
        PONCA_MULTIARCH [[nodiscard]] inline size_t size() const;
        PONCA_MULTIARCH [[nodiscard]] inline size_t capacity() const;
 
        // Modifiers ---------------------------------------------------------------
    protected:
        PONCA_MULTIARCH inline bool pushImpl(const T& _value, T** _addr);
 
    public:
        PONCA_MULTIARCH bool push(T&& _value);
        PONCA_MULTIARCH bool push(const T& _value);
        PONCA_MULTIARCH void pop();
        PONCA_MULTIARCH void reserve(int _capacity);
        PONCA_MULTIARCH void clear();
 
        // Data --------------------------------------------------------------------
    public:
        PONCA_MULTIARCH const container_type& container() const;
 
    protected:
        container_type m_data{};
        compare m_comp;
        size_t m_size{0};     
        size_t m_capacity{0}; 
    };
 
 
    // LimitedPriorityQueue ------------------------------------------------------
 
    template <class T, int N, class Cmp>
        requires ValidCapacity<N>
    PONCA_MULTIARCH LimitedPriorityQueue<T, N, Cmp>::LimitedPriorityQueue() : m_comp()
    {
        PONCA_ASSERT((m_capacity <= N));
    }
 
    template <class T, int N, class Cmp>
        requires ValidCapacity<N>
    PONCA_MULTIARCH LimitedPriorityQueue<T, N, Cmp>::LimitedPriorityQueue(const Self& other)
        : m_data(other.m_data), m_comp(other.m_comp), m_size(other.m_size), m_capacity(other.m_capacity)
    {
        PONCA_ASSERT((m_capacity <= N));
    }
 
    template <class T, int N, class Cmp>
        requires ValidCapacity<N>
    PONCA_MULTIARCH LimitedPriorityQueue<T, N, Cmp>::LimitedPriorityQueue(const int capacity)
        : m_comp(), m_capacity(capacity)
    {
        PONCA_ASSERT((capacity >= 0));
        PONCA_ASSERT((capacity <= N));
    }
 
    template <class T, int N, class Cmp>
        requires ValidCapacity<N>
    template <class InputIt>
    PONCA_MULTIARCH LimitedPriorityQueue<T, N, Cmp>::LimitedPriorityQueue(const int capacity, InputIt first,
                                                                          InputIt last)
        : m_comp(), m_capacity(capacity)
    {
        for (InputIt it = first; it < last; ++it)
        {
            push(*it);
        }
        PONCA_ASSERT((capacity >= 0));
        PONCA_ASSERT((capacity <= N));
    }
} // namespace Ponca
 
#include "limitedPriorityQueue.hpp"