vector_queue.hpp

/*
    SPDX-License-Identifier: MIT
    Copyright © 2016-2023 Amebis
*/
 
#pragma once
 
#include "compat.hpp"
 
namespace stdex
{
    template <class T>
    class vector_queue
    {
    public:
        typedef size_t size_type;
 
        typedef T value_type;
 
        typedef T& reference;
 
        typedef const T& const_reference;
 
        typedef T* pointer;
 
        typedef const T* const_pointer;
 
    public:
        vector_queue(_In_ size_type size_max) :
            m_data(new value_type[size_max]),
            m_head(0),
            m_count(0),
            m_size_max(size_max)
        {
        }
 
        vector_queue(_In_ const vector_queue<value_type> &other) :
            m_data(new value_type[other.m_size_max]),
            m_head(other.m_head),
            m_count(other.m_count),
            m_size_max(other.m_size_max)
        {
            // Copy elements.
            for (size_type i = 0; i < m_count; i++) {
                size_type i_l = abs(i);
                m_data[i_l] =  other.m_data[i_l];
            }
        }
 
        virtual ~vector_queue()
        {
            if (m_data) delete [] m_data;
        }
 
        vector_queue(_Inout_ vector_queue<value_type> &&other) :
            m_data    (std::move(other.m_data    )),
            m_head    (std::move(other.m_head    )),
            m_count   (std::move(other.m_count   )),
            m_size_max(std::move(other.m_size_max))
        {
            // Reset other to consistent state.
            other.m_data     = NULL;
            other.m_head     = 0;
            other.m_count    = 0;
            other.m_size_max = 0;
        }
 
        vector_queue<value_type>& operator=(_In_ const vector_queue<value_type> &other)
        {
            if (this != std::addressof(other)) {
                m_head     = other.m_head;
                m_count    = other.m_count;
                m_size_max = other.m_size_max;
 
                // Copy elements.
                if (m_data) delete [] m_data;
                m_data = new value_type[other.m_size_max];
                for (size_type i = 0; i < m_count; i++) {
                    size_type i_l = abs(i);
                    m_data[i_l] =  other.m_data[i_l];
                }
            }
 
            return *this;
        }
 
        vector_queue<value_type>& operator=(_Inout_ vector_queue<value_type> &&other)
        {
            if (this != std::addressof(other)) {
                m_data     = std::move(other.m_data    );
                m_head     = std::move(other.m_head    );
                m_count    = std::move(other.m_count   );
                m_size_max = std::move(other.m_size_max);
 
                // Reset other to consistent state.
                other.m_data     = NULL;
                other.m_head     = 0;
                other.m_count    = 0;
                other.m_size_max = 0;
            }
 
            return *this;
        }
 
        size_type size() const
        {
            return m_count;
        }
 
        size_type capacity() const
        {
            return m_size_max;
        }
 
        void clear()
        {
            m_count = 0;
        }
 
        bool empty() const
        {
            return m_count == 0;
        }
 
        reference at(_In_ size_type pos)
        {
            if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
            return m_data[abs(pos)];
        }
 
        reference operator[](_In_ size_type pos)
        {
            if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
            return m_data[abs(pos)];
        }
 
        const_reference at(_In_ size_type pos) const
        {
            if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
            return m_data[abs(pos)];
        }
 
        const_reference operator[](_In_ size_type pos) const
        {
            if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
            return m_data[abs(pos)];
        }
 
        reference at_abs(_In_ size_type pos)
        {
            if (pos >= m_size_max) throw std::invalid_argument("Invalid subscript");
            return m_data[pos];
        }
 
        const_reference at_abs(_In_ size_type pos) const
        {
            if (pos >= m_size_max) throw std::invalid_argument("Invalid subscript");
            return m_data[pos];
        }
 
        size_type push_back(_In_ const value_type &v)
        {
            if (m_count < m_size_max) {
                size_type pos = abs(m_count);
                m_data[pos] = v;
                m_count++;
                return pos;
            } else {
                size_type pos = m_head;
                m_data[pos] = v;
                m_head = abs(1);
                return pos;
            }
        }
 
        size_type push_back(_Inout_ value_type&&v)
        {
            if (m_count < m_size_max) {
                size_type pos = abs(m_count);
                m_data[pos] = std::move(v);
                m_count++;
                return pos;
            } else {
                size_type pos = m_head;
                m_data[pos] = std::move(v);
                m_head = abs(1);
                return pos;
            }
        }
 
        void pop_back()
        {
            if (!m_count) throw std::invalid_argument("Empty storage");
            m_count--;
        }
 
        size_type push_front(_In_ const value_type &v)
        {
            m_head = abs(-1);
            if (m_count < m_size_max)
                m_count++;
            m_data[m_head] = v;
            return m_head;
        }
 
        size_type push_front(_Inout_ value_type&&v)
        {
            m_head = abs(-1);
            if (m_count < m_size_max)
                m_count++;
            m_data[m_head] = std::move(v);
            return m_head;
        }
 
        void pop_front()
        {
            if (!m_count) throw std::invalid_argument("Empty storage");
            m_head = abs(1);
            m_count--;
        }
 
        reference front()
        {
            if (!m_count) throw std::invalid_argument("Empty storage");
            return m_data[m_head];
        }
 
        const_reference front() const
        {
            if (!m_count) throw std::invalid_argument("Empty storage");
            return m_data[m_head];
        }
 
        reference back()
        {
            return m_data[tail()];
        }
 
        const_reference back() const
        {
            return m_data[tail()];
        }
 
        size_type head() const
        {
            return m_head;
        }
 
        size_type tail() const
        {
            if (!m_count) throw std::invalid_argument("Empty storage");
            return abs(m_count - 1);
        }
 
        size_type abs(_In_ size_type pos) const
        {
            return (m_head + pos) % m_size_max;
        }
 
    protected:
        value_type *m_data;     
        size_type m_head;       
        size_type m_count;      
        size_type m_size_max;   
    };
}