circular_queue.h

Go to the documentation of this file.

#ifndef CIRCULAR_QUEUE_H_
#define CIRCULAR_QUEUE_H_
   
#include <iostream>   

namespace micros_swarm{
    template <class Type>  
    class cqueue  
    {
        public:
            cqueue()
            {
                tail_ = 0;
                head_ = 0;
                capacity_ = 0;
                data_ = NULL;
            }
            
            cqueue(int capacity)
            {
                tail_ = 0;
                head_ = 0;
                capacity_ = capacity;
                data_ = new Type[capacity_];
            }
            
            cqueue(const cqueue& c)
            {
                tail_ = c.tail_;
                head_ = c.head_;
                capacity_ = c.capacity_;
                data_ = new Type[capacity_];
                memcpy(data_, c.data_, sizeof(Type)*c.length());
            }
            
            cqueue& operator=(const cqueue& c)
            {
                if(this == &c) {
                    return *this;
                }
                delete [] data_;
                tail_ = c.tail_;
                head_ = c.head_;
                capacity_ = c.capacity_;
                data_ = new Type[capacity_];
                memcpy(data_, c.data_, sizeof(Type)*c.length());
                return *this;
            }
            
            ~cqueue()
            {
                delete []data_;
            }
            
            bool empty()
            {
                if (head_ == tail_) {
                    return true;
                }
                else {
                    return false;
                }
            }
            
            bool full()
            {
                 if ((tail_+1)%capacity_ == head_) {
                     return true;
                 }
                 else {
                     return false;
                 }
            }
            
            void push(Type x)
            {
                if (!full()) {
                    data_[tail_] = x;
                    tail_ = (tail_+1)%capacity_;
                }
                else {
                    std::cout<<"cqueue is full."<<std::endl;
                }
            }
            
            void pop()
            {
                if (!empty()) {
                    head_ = (head_ + 1) % capacity_;
                }
                else {
                    std::cout<<"cqueue is empty."<<std::endl;
                }
            }
            
            const Type& front()
            {
                return data_[head_];
            }
            
            int size()
            {
                return (tail_-head_+capacity_)%capacity_;
            }
            
            void print()
            {
                int cnt = head_;
                if (head_ > tail_) {
                    tail_ += capacity_;
                }
                while(cnt <= tail_-1) {
                    std::cout << data_[cnt] << " ";
                    cnt++;
                }
               std::cout<<std::endl;
            }
        private:
            Type *data_;
            int capacity_;
            int tail_;
            int head_;
    };   
};
   
#endif