20_03_esercizio_tape-queue.cpp

#include <iostream>
using namespace std;


template <typename T>
class Node{

    private:

        T data;
        Node<T>* next;

    public:

        Node() : data(NULL), next(nullptr) {}
        Node(const T& _data, Node<T>* _next = nullptr) : data(_data), next(_next) {}

        const T& get_data() const {return this->data;}
        Node<T>* get_next() const {return this->next;}

        void set_data(const T& _data) {this->data = _data;}
        void set_next(Node<T>* _next) {this->next = _next;}

};



template <typename T>
class TapeQueue{

    private:

        Node<T>* front;
        Node<T>* back;
        size_t size;

    public:

        TapeQueue() : front(nullptr), size(0) {}

        ~TapeQueue() {
            while(!this->is_empty())
                this->dequeue();
        }

        size_t get_size() const {return this->size;}

        Node<T>* get_front() const {return this->front;}
        Node<T>* get_back() const {return this->back;}

        void set_front(Node<T>* _front) {this->front = _front;}
        void set_back(Node<T>* _back) {this->back = _back;}

        bool is_empty() const {return (this->front == nullptr);}

        TapeQueue<T>* rotate(size_t pos = 1) {
            if(!this->is_empty()){
                for( ; pos > 0; pos--){    
                    this->set_front(this->get_front()->get_next());
                    this->set_back(this->get_back()->get_next());
                }
            }
            return this;
        }

        TapeQueue<T>* enqueue(Node<T>* _node) {
            if(this->is_empty())
                this->set_front(_node);
            else
                this->get_back()->set_next(_node);
            this->set_back(_node);
            _node->set_next(this->get_front());
            this->size++;
            return this;
        }

        TapeQueue<T>* enqueue(const T& _data) {
            return this->enqueue(new Node<T>(_data));
        }

        TapeQueue<T>* dequeue() {
            if(!this->is_empty()){
                Node<T>* del = this->get_front();
                if(del->get_next() == del){
                    this->set_front(nullptr);
                    this->set_back(nullptr);
                }
                else{
                    this->set_front(del->get_next());
                    this->get_back()->set_next(this->get_front());

                }
                this->size--;
                delete del;
            }
            return this;
        }

        TapeQueue<T>* extend(TapeQueue<T>*& ex) {
            if(!ex->is_empty()){
                if(this->is_empty()){
                    this->set_front(ex->get_front());
                    this->set_back(ex->get_front());
                }
                else{
                    this->get_back()->set_next(ex->get_front());
                    this->set_back(ex->get_back());
                    ex->get_back()->set_next(this->get_front());
                }
            }
            this->size += ex->get_size();
            ex = nullptr;
            return this;
        }

        void print() const {
            if(!this->is_empty()){
                cout << "(" << this->get_size() << ") " << this->get_front()->get_data() << " ";
                Node<T>* curr = this->get_front();
                while(curr->get_next() != this->get_front()){
                    cout << curr->get_next()->get_data() << " ";
                    curr = curr->get_next();
                }
            }
            else
                cout << "(" << this->get_size() << ")";
        }

};

template <typename T>
ostream& operator<<(ostream& out, const TapeQueue<T>& obj){
    obj.print();
    return out;
}



int main(){

    TapeQueue<int>* Q = new TapeQueue<int>();

    Q->enqueue(1); cout << *Q << endl;
    Q->enqueue(2); cout << *Q << endl;
    Q->enqueue(3); cout << *Q << endl;
    Q->enqueue(4); cout << *Q << endl;
    Q->enqueue(5); cout << *Q << endl;

    Q->rotate(3); cout << *Q << endl;

    TapeQueue<int>* R = new TapeQueue<int>();
    R->enqueue(10)->enqueue(20)->enqueue(30);  
    Q->extend(R); cout << *Q << endl;

    Q->rotate(3); cout << *Q << endl;

    Q->dequeue(); cout << *Q << endl;
    Q->dequeue(); cout << *Q << endl;
    Q->dequeue(); cout << *Q << endl;
    Q->dequeue(); cout << *Q << endl;
    Q->dequeue(); cout << *Q << endl;

    delete Q;
    delete R;

    return 0;
}