PriorityMultiQueue.hpp

#pragma once
#ifndef __H__OCULAR_UTILS_PRIORITY_MULTI_QUEUE__H__
#define __H__OCULAR_UTILS_PRIORITY_MULTI_QUEUE__H__

#include "CircularQueue.hpp"
#include "Priority.hpp"

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

namespace Ocular
{
    namespace Utils
    {
        template<typename T, std::size_t MAX_ELEMENTS>
        class PriorityMultiQueue
        {
        public:
            
            PriorityMultiQueue()
            {
            
            }
            
            ~PriorityMultiQueue()
            {
            
            }

            bool enqueue(T const element, Core::Priority priority)
            {
                bool result = false;

                switch(priority)
                {
                case Core::Priority::Critical:
                    result = m_CriticalPriority.enqueue(element);
                    break;

                case Core::Priority::High:
                    result = m_HighPriority.enqueue(element);
                    break;

                case Core::Priority::Medium:
                    result = m_MediumPriority.enqueue(element);
                    break;

                case Core::Priority::Low:
                    result = m_LowPriority.enqueue(element);
                    break;
                    
                default:
                    break;
                }

                return result;
            }

            bool dequeue()
            {
                // Short-circuit evaluation ensures that we will 
                // return once a successful dequeue has occurred.

                return m_CriticalPriority.dequeue() ||
                       m_HighPriority.dequeue()     ||
                       m_MediumPriority.dequeue()   ||
                       m_LowPriority.dequeue();
            }
            
            bool dequeue(T& retElement)
            {
                // Short-circuit evaluation ensures that we will 
                // return once a successful dequeue has occurred.

                return m_CriticalPriority.dequeue(retElement) ||
                       m_HighPriority.dequeue(retElement)     ||
                       m_MediumPriority.dequeue(retElement)   ||
                       m_LowPriority.dequeue(retElement);
            }
            
            bool dequeue(Core::Priority priority, T& retElement)
            {
                bool result = false;

                switch(priority)
                {
                case Core::Priority::Critical:
                    result = m_CriticalPriority.dequeue(element);
                    break;

                case Core::Priority::High:
                    result = m_HighPriority.dequeue(element);
                    break;

                case Core::Priority::Medium:
                    result = m_MediumPriority.dequeue(element);
                    break;

                case Core::Priority::Low:
                    result = m_LowPriority.dequeue(element);
                    break;
                    
                default:
                    break;
                }

                return result;
            }

            unsigned getNumElements() const 
            {
                return getNumElementsCritical() +
                       getNumElementsHigh() +
                       getNumElementsMedium() +
                       getNumElementsLow();
            }

            unsigned getNumElementsCritical() const
            {
                return m_CriticalPriority.getNumElements();
            }
            
            unsigned getNumElementsHigh() const
            {
                return m_HighPriority.getNumElements();
            }
            
            unsigned getNumElementsMedium() const
            {
                return m_MediumPriority.getNumElements();
            }
            
            unsigned getNumElementsLow() const
            {
                return m_LowPriority.getNumElements();
            }

            bool empty()
            {
                return (getNumElements() == 0);
            }

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

        protected:

        private:

            CircularQueue<T, MAX_ELEMENTS> m_CriticalPriority;
            CircularQueue<T, MAX_ELEMENTS> m_HighPriority;
            CircularQueue<T, MAX_ELEMENTS> m_MediumPriority;
            CircularQueue<T, MAX_ELEMENTS> m_LowPriority;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif