CircularQueue.hpp

#pragma once
#ifndef __H__OCULAR_UTILS_CIRCULAR_QUEUE__H__
#define __H__OCULAR_UTILS_CIRCULAR_QUEUE__H__

#include <array>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Utils
    {
        template<typename T, std::size_t MAX_ELEMENTS>
        class CircularQueue
        {
        public:

            CircularQueue()
                : m_Last(MAX_ELEMENTS - 1), m_Head(0), m_Tail(0), m_NumElements(0)
            {
            }

            ~CircularQueue()
            {
            }

            bool enqueue(T const element)
            {
                bool retVal = false;

                if(m_NumElements < MAX_ELEMENTS)
                {
                    m_Array[m_Tail] = element;
                    incrementTail();
                    retVal = true;
                }

                return retVal;
            }

            bool dequeue(T& retElement)
            {
                bool retVal = false;

                if(m_NumElements > 0)
                {
                    retElement = m_Array[m_Head];
                    
                    incrementHead();
                    retVal = true;
                }

                return retVal;
            }

            bool dequeue()
            {
                bool retVal = false;

                if(m_NumElements > 0)
                {
                    incrementHead();
                    retVal = true;
                }

                return retVal;
            }

            bool peek(T& retElement)
            {
                bool retVal = false;;

                if(m_NumElements > 0)
                {
                    retElement = m_Array[m_Head];
                    retVal = true;
                }
                
                return retVal;
            }

            unsigned getNumElements() const
            {
                return m_NumElements;
            }

            void clear()
            {
                while(dequeue());
            }

        protected:

        private:

            void incrementHead()
            {
                if (m_NumElements > 0)
                {
                    
                    if (m_Head != m_Last)
                    {
                        m_Head++;
                    }
                    else
                    {
                        m_Head = 0;
                    }

                    m_NumElements--;
                }
            }

            void incrementTail()
            {
                if (m_NumElements < MAX_ELEMENTS)
                {
                    if (m_Tail != m_Last)
                    {
                        m_Tail++;
                    }
                    else
                    {
                        m_Tail = 0;
                    }

                    m_NumElements++;
                }
            }

            //----------------------------------------

            unsigned m_NumElements;
            unsigned m_Head;
            unsigned m_Tail;
            unsigned m_Last;

            std::array<T, MAX_ELEMENTS> m_Array;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif