/*
 * A very simple queue template
 *
 * Author:  Mark A. Sheldon, Tufts University, Fall 2016
 *
 */
#ifndef C15QUEUE_H
#define C15QUEUE_H

#include <string>
#include <stdexcept>

template<typename ElemType>
class Queue
{
public:
        Queue(int the_capacity = 10);
        ~Queue();

        void     enqueue(ElemType value);
        ElemType dequeue();
        bool     is_full();
        bool     is_empty();

private:
        int       capacity, size;
        int       front, back;
        ElemType *queue;

        int  next_index(int idx);

        void enforce(bool condition, std::string message);
};

template<typename ElemType>
Queue<ElemType>::Queue(int the_capacity)
{
        capacity = the_capacity;
        size     = 0;
        front    = 0;
        back     = 0;
        queue    = new ElemType[capacity];
}

template<typename ElemType>
Queue<ElemType>::~Queue()
{
        delete [] queue;
        queue    = NULL;
        capacity = size = front = back = 0;
}

template<typename ElemType>
void Queue<ElemType>::enqueue(ElemType value)
{
        enforce(not is_full(), "enqueue on full queue");

        queue[back] = value;
        back  = next_index(back);
        size += 1;
}

template<typename ElemType>
ElemType Queue<ElemType>::dequeue()
{
        enforce(not is_empty(), "dequeue from empty queue");

        int result_idx = front;
        front = next_index(front);
        size -= 1;
        return queue[result_idx];
}

template<typename ElemType>
bool Queue<ElemType>::is_full()
{
        return size == capacity;
}

template<typename ElemType>
bool Queue<ElemType>::is_empty()
{
        return size == 0;
}

template<typename ElemType>
int Queue<ElemType>::next_index(int n)
{
        return (n + 1) % capacity;
}

/*
 * Inside class to avoid polluting client's namespace
 */
template<typename ElemType>
void Queue<ElemType>::enforce(bool condition, std::string message)
{
        if (not condition)
                throw std::runtime_error(message);
}

#endif