CircularQueue.h

Go to the documentation of this file.

#ifndef CIRCULARQUEUE_H_
#define CIRCULARQUEUE_H_

#include <iostream>

using std::cerr;
using std::endl;

#include <cstdlib>

#include <algorithm>

using std::fill;


template <class T>
class CircularQueue
{

public:

    CircularQueue(size_t size, T v);

    virtual ~CircularQueue();


    T &get(int position = 0) const;



    void put(const T &elem);
    
    
    void moveMark(int steps);
    

     T &getFromMark(int position) const;
     
        void reset(T v);        
        
        void putArray(double *arr, int len);


protected:
    size_t _size;
    unsigned current;
    unsigned currentMark;
    T *entry;
};


template <class T>
CircularQueue<T>::CircularQueue(size_t size, T v)
        : _size(size)
{
    entry = new T[_size];
    reset(v);
}


template <class T>
CircularQueue<T>::~CircularQueue()
{
    delete [] entry;
}


template <class T>
inline void CircularQueue<T>::reset(T v)
{
    fill(entry, entry + _size, v);
    current = 0;
    currentMark = 0;
}


template <class T>
inline T & CircularQueue<T>::get(int position) const
{
    int myIndex = current - position;
    if ( myIndex < 0 ) myIndex += _size;
    return entry[myIndex] ;
}

template <class T>
inline void CircularQueue<T>::putArray(double *arr, int len) 
{
    if (current + len >= _size) {
        int first_slice = _size - current - 1; 
        memcpy((char *)(entry + current + 1), (char *)arr, sizeof(double)*(first_slice));       
        memcpy((char *)(entry), (char *)(arr + first_slice), sizeof(double)*(len - first_slice));       
    }
    else {
        memcpy((char *)(entry + current + 1), (char *)arr, sizeof(double)*len);
    }
    current = (current + len) % _size;
}


template <class T>
inline T & CircularQueue<T>::getFromMark(int position) const
{
        int myIndex = currentMark - position;
        if (myIndex < 0 ) myIndex += _size;
        return entry [myIndex]; 
}


template <class T>
inline void CircularQueue<T>::moveMark(int steps) 
{
        currentMark += steps;
        if (currentMark > _size-1)
                currentMark -= _size;
}



template <class T>
inline void CircularQueue<T>::put(const T &elem)
{
    if (current < _size-1)
        current++;
    else
        current=0;

    entry[current] = elem;
}


#endif /*CIRCULARQUEUE_H_*/

---