linkedlist.h

#ifndef __LINKEDLIST_H__
#define __LINKEDLIST_H__

#include "Node.h"
#include <string>

typedef enum {
    OK ,
    HeadNull,
    TailNull,
    HeadPrevious,
    HeadNextNull,
    TailNext,
    TailPreviousNull,
    HeadTail,
    IncorrectLink
} ListStatus ;

template <class T>
class LinkedList {
private:
    Node<T>* head;
    Node<T>* tail;
    int quantity;
    
public:
    LinkedList(void);
    ~LinkedList(void);

    Node<T>* getHead(void);
    Node<T>* getTail(void);
    
    T get(int);
    int search(T);
    bool insertEnd(T);
    bool insertBegin(T);
    bool insert(int, T);

    T removeEnd(void);
    T removeBegin(void);
    T remove(int);
    
    void print(void);
    
    bool isEmpty(void);
    int getQuantity(void);
};

template <class T>
LinkedList<T>::LinkedList(){
    this->head = new Node<T>();
    this->tail = new Node<T>();
    
    this->head->setNext(this->tail);
    this->head->setPrevious(NULL);

    this->tail->setNext(NULL);
    this->tail->setPrevious(this->head);

    this->quantity = 0;
}

template <class T>
LinkedList<T>::~LinkedList(){

    Node<T>* no = this->head;
    
    while(no != this->tail){

        Node<T>* toDestroy = no;
        
        no = no->getNext();
        
        delete toDestroy;
    }
    
    delete this->tail;
}

template <class T>
int LinkedList<T>::getQuantity(void) {
    return this->quantity;
}

template <class T>
bool LinkedList<T>::isEmpty(void) {
    return this->quantity == 0;
}

template <class T>
Node<T>* LinkedList<T>::getHead(void) {
    return this->head;
}

template <class T>
Node<T>* LinkedList<T>::getTail(void) {
    return this->tail;
}


template <class T>
T LinkedList<T>::get(int i) {
   
    int count = 1;
    
    T result;
    for(Node<T>* no = this->head->getNext(); no != this->tail; no = no->getNext()){
        if( i == count ){

            result = no->getValue();
            break;
        }
        count++;
    }
    
    return result;
}

template <class T>
int LinkedList<T>::search(T node_content) {
    int count = 1;
    
    for(Node<T>* no = this->head->getNext(); no != this->tail; no = no->getNext()) {
        T value = no->getValue();
        if( no == value )
        {
            return count;
        }
        count++;
    }
    
    return -1;
}

template <class T>
void LinkedList<T>::print(void) {
    for(Node<T>* no = this->head->getNext(); no != this->tail; no = no->getNext())
    {
        std::cout << no->getValue() << " ";
    }
    std::cout << std::endl;
}

template <class T>
bool LinkedList<T>::insertBegin(T node_content) {

    Node <T>* no = this->getHead();
    Node <T>* new_no = new Node<T>(node_content);

    new_no->setNext(no->getNext()); 
    new_no->setPrevious(no);
    new_no->getNext()->setPrevious(new_no);
    new_no->getPrevious()->setNext(new_no); 
    quantity++;
    
    return true;
}

template <class T>
bool LinkedList<T>::insertEnd(T node_content)
{
    Node <T>* no = this->getTail();
    Node <T>* new_no = new Node<T>(node_content);

    new_no->setNext(no); 
    new_no->setPrevious(no->getPrevious());
    new_no->getNext()->setPrevious(new_no);
    new_no->getPrevious()->setNext(new_no); 
    quantity++;
    return true;
}

template <class T>
bool LinkedList<T>::insert(int i, T s)
{
    int y = 0;
    Node <T>* x = new Node<T>(s) ;
    Node<T>* n = this->getHead();
        while (y != i){
            if(n == this->getTail()){
                return false;
            }else{
                n = n->getNext();
                y++;
            }
        }
        if( i == y){
        x->setNext(n); 
        x->setPrevious(n->getPrevious());
        n->setPrevious(x);
        n->getPrevious()->getPrevious()->setNext(x); 
        
        quantity++;
        return true;
       }
      return false;
}



template <class T>
T LinkedList<T>::removeEnd(void) {
    T no_toremove;
    Node<T>* no ;
    no = this->getTail()->getPrevious();
    no_toremove = no->getValue();
    this->getTail()->setPrevious(this->getTail()->getPrevious()->getPrevious() );
    this->getTail()->getPrevious()->setNext(this->getTail()); 
    
    quantity--;
    delete no;
    return no_toremove;
}

template <class T>
T LinkedList<T>::removeBegin(void) {
    T no_toremove;
    Node<T>* no ;
    no = this->getHead()->getNext();
    no_toremove = no->getValue();
    this->getHead()->setNext(this->getHead()->getNext()->getNext() );
    this->getHead()->getNext()->setPrevious(this->getHead()); 
    quantity--;

    delete no;
    return no_toremove;
        
}

template <class T>
T LinkedList<T>::remove(int indice) {
    int count = 0;

    Node<T>* n = this->getHead();
        while (count != indice){
                n = n->getNext();
                count++;
        }
        if( indice == count){
        T valor = n->getValue();
        n->getNext()->setPrevious(n->getPrevious()); 
        n->getPrevious()->setNext(n->getNext());
        quantity--;
        delete n;
        return valor;
       }
       return "";
}
#endif /* defined(__LinkedList__LinkedList__) */