ustd_queue.h

// ustd_queue.h - ustd queue class
 
#pragma once
 
namespace ustd {
 
// Helper class for queue iterators:
template <typename T> class queueIterator {
  private:
    T *values_ptr;
    unsigned int position;
    unsigned int maxSize;
 
  public:
    queueIterator(T *values_ptr, unsigned int p, unsigned int maxSize)
        : values_ptr{values_ptr}, position{p}, maxSize(maxSize) {
    }
 
    bool operator!=(const queueIterator<T> &other) const {
        return !(*this == other);
    }
 
    bool operator==(const queueIterator<T> &other) const {
        return position == other.position;
    }
 
    queueIterator &operator++() {
        position = (position + 1) % maxSize;
        return *this;
    }
 
    T &operator*() const {
        return *(values_ptr + position);
    }
};
 
template <class T> class queue {
  private:
    T *que;
    unsigned int peakSize;
    unsigned int maxSize;
    unsigned int size;
    unsigned int quePtr0;
    unsigned int quePtr1;
    T bad = {};
 
  public:
    queue(unsigned int maxQueueSize) : maxSize(maxQueueSize) {
        quePtr0 = 0;
        quePtr1 = 0;
        size = 0;
        peakSize = 0;
        que = (T *)malloc(sizeof(T) * maxSize);
        if (que == nullptr)
            maxSize = 0;
    }
 
    queue(const queue &qu) {
        peakSize = qu.peakSize;
        maxSize = qu.maxSize;
        size = qu.size;
        quePtr0 = qu.quePtr0;
        quePtr1 = qu.quePtr1;
        bad = qu.bad;
        que = (T *)malloc(sizeof(T) * maxSize);
        if (que == nullptr) {
            maxSize = 0;
            size = 0;
        } else {
            unsigned int in = quePtr0;
            for (unsigned int i = 0; i < size; i++) {
                que[in] = qu.que[in];
                in = (in + 1) % maxSize;
            }
        }
    }
 
    ~queue() {
        if (que != nullptr) {
            free(que);
            que = nullptr;
        }
    }
 
    // iterators
    queueIterator<T> begin() {
        return queueIterator<T>(que, quePtr0, maxSize);
    }
    queueIterator<T> end() {
        return queueIterator<T>(que, (quePtr0 + size) % maxSize, maxSize);
    }
 
    queueIterator<const T> begin() const {
        return queueIterator<const T>(que, quePtr0, maxSize);
    }
 
    queueIterator<const T> end() const {
        return queueIterator<const T>(que, (quePtr0 + size) % maxSize, maxSize);
    }
 
    void getInternalStartStopPtrs(unsigned int *p0, unsigned int *p1) {
        *p0 = quePtr0;
        *p1 = quePtr1;
    }
 
    bool push(T ent) {
        if (size >= maxSize) {
            return false;
        }
        que[quePtr1] = ent;
        quePtr1 = (quePtr1 + 1) % maxSize;
        ++size;
        if (size > peakSize) {
            peakSize = size;
        }
        return true;
    }
 
    T pop() {
        if (size == 0)
            return bad;
        T ent = que[quePtr0];
        quePtr0 = (quePtr0 + 1) % maxSize;
        --size;
        return ent;
    }
 
    void setInvalidValue(T &entryInvalidValue) {
        bad = entryInvalidValue;
    }
 
    bool isEmpty() {
        if (size == 0)
            return true;
        else
            return false;
    }
 
    unsigned int length() {
        return (size);
    }
 
    unsigned int peak() {
        return (peakSize);
    }
};
}  // namespace ustd