QueueBuffer.hpp

#pragma once
#include <NDEVR/Buffer.h>
namespace NDEVR
{
    template<class t_type, class t_memory_manager = BufferAllocator<t_type, DetermineAlignment<sizeof(t_type)>(), ObjectInfo<t_type>::Primitive, uint04, false>>
    class QueueBuffer : protected Buffer<t_type, t_memory_manager>
    {
    public:
        using t_index_type = typename t_memory_manager::index_type;
        constexpr QueueBuffer()
            : Buffer<t_type, t_memory_manager>()
            , m_start(0)
            , m_end(0)
        {}
        constexpr QueueBuffer(const QueueBuffer& buffer)
            : Buffer<t_type, t_memory_manager>(buffer)
            , m_start(buffer.m_start)
            , m_end(buffer.m_end)
        {}
        constexpr QueueBuffer(const Buffer<t_type, t_memory_manager>& buffer)
            : Buffer<t_type, t_memory_manager>(buffer)
            , m_start(0)
            , m_end(buffer.size())
        {}
        constexpr QueueBuffer(QueueBuffer&& buffer) noexcept
            : Buffer<t_type, t_memory_manager>(std::move(buffer))
            , m_start(buffer.m_start)
            , m_end(buffer.m_end)
        {}
 
        explicit QueueBuffer(uint04 size)
            : Buffer<t_type, t_memory_manager>(size)
            , m_start(0)
            , m_end(0)
        {}
        void push(t_type&& object)
        {
            if(m_end == Buffer<t_type, t_memory_manager>::size())
            {
                Buffer<t_type, t_memory_manager>::add(std::move(object));
            }
            else
            {
                std::swap(Buffer<t_type, t_memory_manager>::get(m_end), object);
            }
            m_end++;
        }
        void push(const t_type& object)
        {
            if (m_end == Buffer<t_type, t_memory_manager>::size())
            {
                Buffer<t_type, t_memory_manager>::add(object);
            }
            else
            {
                Buffer<t_type, t_memory_manager>::get(m_end) = object;
            }
            m_end++;
        }
        void pushAll(const t_type* object, uint04 size)
        {
            if (size == 0)
                return;
            uint04 current_size = Buffer<t_type, t_memory_manager>::size();
            if (size > current_size - m_end)
                Buffer<t_type, t_memory_manager>::template addSpace<true>(size - (current_size - m_end));
            for (uint04 i = 0; i < size; i++)
                Buffer<t_type, t_memory_manager>::get(i + m_end) = *(object + i);
            m_end += size;
        }
        void pushAll(const Buffer<t_type>& object)
        {
            pushAll(object.begin(), object.size());
        }
        void clear()
        {
            m_start = m_end;
        }
        void pop()
        {
            m_start++;
            checkMove();
        }
        void popAll(uint04 size)
        {
            m_start += size;
            checkMove();
        }
 
        [[nodiscard]] decltype(auto) front()
        {
            return Buffer<t_type, t_memory_manager>::get(m_start);
        }

 
        [[nodiscard]] decltype(auto) front() const
        {
            return Buffer<t_type, t_memory_manager>::get(m_start);
        }
 
        bool empty() const
        {
            return m_end == m_start;
        }
        [[nodiscard]] constexpr static t_type Type() { return Buffer<t_type, t_memory_manager>::Type(); }
 
        [[nodiscard]] constexpr t_memory_manager& memoryInterface()
        {
            return Buffer<t_type, t_memory_manager>::memoryInterface();
        }
        [[nodiscard]] constexpr const t_memory_manager& memoryInterface() const
        {
            return Buffer<t_type, t_memory_manager>::memoryInterface();
        }
        inline QueueBuffer& operator=(const QueueBuffer& buffer) noexcept
        {
            m_start = buffer.m_start;
            m_end = buffer.m_end;
            Buffer<t_type, t_memory_manager>::operator=(buffer);
            return *this;
        }
        inline QueueBuffer& operator=(QueueBuffer&& buffer) noexcept
        {
            m_start = buffer.m_start;
            m_end = buffer.m_end;
            Buffer<t_type, t_memory_manager>::operator=(std::move(buffer));
            return *this;
        }
        inline const t_type& operator[](t_index_type value) const noexcept
        {
            return Buffer<t_type, t_memory_manager>::get(value + m_start);
        }
        inline t_type& operator[](t_index_type value) noexcept
        {
            return Buffer<t_type, t_memory_manager>::get(value + m_start);
        }
        uint04 size() const
        {
            return m_end - m_start;
        }
        inline const t_type& last() const
        {
            return Buffer<t_type, t_memory_manager>::get(m_end - 1);
        }
        inline t_type& last()
        {
            return Buffer<t_type, t_memory_manager>::get(m_end - 1);
        }
    protected:
        void checkMove()
        {
            //Check to see if we should resize back to 0
            if(m_start * 2 >= Buffer<t_type, t_memory_manager>::size())
            {
                Buffer<t_type, t_memory_manager>::removeIndices(0, m_start);
                m_end -= m_start;
                m_start = 0;
            }
        }
    protected:
        uint04 m_start;
        uint04 m_end;
    };
}