queue.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <propeller.h>
 
// Need to include this since PropWare.h is not imported
#ifdef __PROPELLER_COG__
#define PropWare PropWare_cog
#define virtual
#endif
 
namespace PropWare {
 
template<typename T>
class Queue {
    public:
        template<size_t N>
        Queue (T (&array)[N], const int lockNumber = locknew())
                : m_array(array),
                  m_arrayLength(N),
                  m_lockNumber(lockNumber),
                  m_size(0),
                  m_head(0),
                  m_tail(0) {
            lockclr(this->m_lockNumber);
        }
 
        Queue (T *array, const size_t length, const int lockNumber)
                : m_array(array),
                  m_arrayLength(length),
                  m_lockNumber(locknew()),
                  m_size(0),
                  m_head(0),
                  m_tail(0) {
            lockclr(this->m_lockNumber);
        }
 
        ~Queue () {
            lockclr(this->m_lockNumber);
            lockret(this->m_lockNumber);
        }
 
        size_t size () const {
            return this->m_size;
        }
 
        bool is_empty () const {
            return 0 == this->size();
        }
 
        bool is_full () const {
            return this->m_arrayLength == this->size();
        }
 
        void clear () {
            this->m_size = 0;
        }
 
        virtual Queue &enqueue (const T &value) {
            // Lock the state and save off these volatile variables into local memory
            while (lockset(this->m_lockNumber));
            unsigned int head = this->m_head;
            unsigned int tail = this->m_tail;
            size_t       size = this->m_size;
 
            // Move the head pointer
            if (0 == size)
                head = tail = 0;
            else {
                ++head;
                // If the head has reached the end of the memory block, rollover
                if (head == this->m_arrayLength)
                    head = 0;
            }
 
            this->m_array[head] = value;
 
            // If the buffer wasn't full, increment the size
            if (size == this->m_arrayLength) {
                // Move the tail forward and roll over if necessary
                ++tail;
                if (tail == this->m_arrayLength)
                    tail = 0;
            } else {
                ++size;
            }
 
            // Unlock the state and upload these variables back to volatile memory
            this->m_head = head;
            this->m_tail = tail;
            this->m_size = size;
            lockclr(this->m_lockNumber);
 
            return *this;
        }
 
        Queue &insert (const T &value) {
            return this->enqueue(value);
        }
 
        virtual T dequeue () {
            // Lock the state and save off these volatile variables into local memory
            while (lockset(this->m_lockNumber));
            unsigned int head = this->m_head;
            unsigned int tail = this->m_tail;
            size_t       size = this->m_size;
 
            T *retVal;
            if (size) {
                retVal = &this->m_array[tail];
 
                --size;
 
                if (size) {
                    // Move the tail forward and roll over if necessary
                    ++tail;
                    if (tail == this->m_arrayLength)
                        tail = 0;
                }
            } else
                retVal = NULL;
 
            // Unlock the state and upload these variables back to volatile memory
            this->m_head = head;
            this->m_tail = tail;
            this->m_size = size;
            lockclr(this->m_lockNumber);
 
            return *retVal;
        }
 
        T peek () const {
            return this->m_array[this->m_tail];
        }
 
        bool check (const T &value) const {
            const bool valid = &value == NULL;
            return valid;
        }
 
    protected:
        T            *m_array;
        const size_t m_arrayLength;
        const int    m_lockNumber;
 
        volatile size_t       m_size;
        volatile unsigned int m_head;
        volatile unsigned int m_tail;
};
 
}
 
#ifdef __PROPELLER_COG__
#undef virtual
#endif