my_priority_queue.h

Go to the documentation of this file.

#ifndef MY_PRIORITY_QUEUE_H
#define MY_PRIORITY_QUEUE_H

#include <vector>
using namespace std;


template <class T, class Compare> 
class MyPriorityQueue {

private:
        vector<T> waiting_queue; 
        int current_pos;

public:
        /* Typical priority queue functions (see priority queue in STL) */
        T top(void);
        void pop(void);
        int push(const T& elt);
        int size(void) const;
        bool empty(void) const;

        /* Additionnal functions for debug/scheduling purposes */
        T& at(int pos);
        const T& at(int pos) const;

        /* Look into the vector with current_pos variable (used by scheduling) */
        void resetCurrentPosition();
        T next_element(void);
        const T& current_element() const;
        T& current_element();
        void erase_current_element(); 
        const int current_position() const;
        bool last_element() const;

        void update_queue(void);
};

template <class T, class Compare> 
T MyPriorityQueue<T, Compare>::top(void) {
        return waiting_queue.front();
}

template <class T, class Compare> 
void MyPriorityQueue<T, Compare>::pop(void) {
        waiting_queue.erase(waiting_queue.begin());
        current_pos -= 1;
}

template <class T, class Compare> 
int MyPriorityQueue<T, Compare>::push(const T& elt) {
        // Version 1: basic FIFO, Always put the element at the end
        //waiting_queue.push_back(T(elt));

        // Version 2: real priority queue coupled with FIFO when comp is equal
        typename vector<T>::iterator it;
        Compare comp;
        bool inserted = false;
        int position = 0;
        for(it = waiting_queue.begin(); it < waiting_queue.end(); it++) {
                if(comp(elt, *it)) {
                        // Insert element
                        waiting_queue.insert(it, T(elt));
                        inserted = true;
                        break;
                }
                position++;
        }

        if(!inserted) waiting_queue.push_back(T(elt)); // Insert at the end

        return position;
}

template <class T, class Compare> 
int MyPriorityQueue<T, Compare>::size(void) const {
        return (int) waiting_queue.size();
}

template <class T, class Compare> 
bool MyPriorityQueue<T, Compare>::empty(void) const {
        return waiting_queue.empty();
}

template <class T, class Compare> 
T& MyPriorityQueue<T, Compare>::at(int pos) {
        return waiting_queue.at(pos);
}

template <class T, class Compare> 
const T& MyPriorityQueue<T, Compare>::at(int pos) const {
        return waiting_queue.at(pos);
}

template <class T, class Compare> 
void MyPriorityQueue<T, Compare>::update_queue(void) {
        vector<T> waiting_queue_copy(waiting_queue);

        waiting_queue.clear();
        for(int i = 0; i < (int) waiting_queue_copy.size(); i++) push(waiting_queue_copy.at(i));
}

template <class T, class Compare> 
void MyPriorityQueue<T, Compare>::resetCurrentPosition() {
        current_pos = -1;
}

template <class T, class Compare> 
T MyPriorityQueue<T, Compare>::next_element(void) {
        current_pos += 1;
        return waiting_queue.at(current_pos);
}
        
template <class T, class Compare> 
const T& MyPriorityQueue<T, Compare>::current_element() const {
        return waiting_queue.at(current_pos);
}

template <class T, class Compare> 
T& MyPriorityQueue<T, Compare>::current_element() {
        return waiting_queue.at(current_pos);
}

template <class T, class Compare> 
void MyPriorityQueue<T, Compare>::erase_current_element() {
        waiting_queue.erase(waiting_queue.begin() + current_pos);
        current_pos -= 1;
}

template <class T, class Compare> 
const int MyPriorityQueue<T, Compare>::current_position() const {
        return current_pos;
}

template <class T, class Compare> 
bool MyPriorityQueue<T, Compare>::last_element() const {
        return (current_pos >= (int)(waiting_queue.size()-1));
}

#endif