LinkedQueue

//  Copyright [2017] <Jean Leopoldo>
#ifndef STRUCTURES_LINKED_QUEUE_H
#define STRUCTURES_LINKED_QUEUE_H

#include <cstdint>
#include <stdexcept>

namespace structures {

template<typename T>
//! class LinkedQueue
/*
*  class LinkedQueue
*/
class LinkedQueue {
 public:
//! constructor LinkedQueue
/*
*  constructor LinkedQueue
*/
    LinkedQueue() {
        head = nullptr;
        tail = nullptr;
        size_ = 0;
    }
//! destructor LinkedQueue
/*
*  destructor LinkedQueue
*/
    ~LinkedQueue() {
        clear();
    }
//! clear
/*
*  clear list
*/
    void clear() {
        Node *aux;
        while (!empty()) {
            aux = head;
            head = head->next();
            delete aux;
        }
        size_ = 0;
        head = nullptr;
        tail = nullptr;
    }
//! enqueue
/*
*  insert node at the beginning of the queue
*/
    void enqueue(const T& data) {
        Node *node = new Node(data);
        if (node == nullptr)
            throw std::out_of_range("full");
        if (empty()) {
            size_++;
            head = node;
            tail = node;
        } else {
            size_++;
            head = node;
        }
    }
//! dequeue
/*
*  remove node from the end of the queue and return its data
*/
    T dequeue() {
        if (empty())
            throw std::out_of_range("empty");
        if (size_ == 1) {
            T data = head->data();
            size_--;
            head = nullptr;
            tail = nullptr;
            return data;
        }
        size_--;
        Node *aux = head;
        T data = tail->data();
        for (int i = 0; i < size_-2; i++)
            aux = aux->next();
        aux->next(nullptr);
        tail->next(aux);
        return data;
    }
//! front
/*
*  returns data of the first node
*/
    T& front() const {
        if (empty())
            throw std::out_of_range("empty");
        return head->data();
    }
//! back
/*
*  returns data of the last node
*/
    T& back() const {
        if (empty())
            throw std::out_of_range("empty");
        return tail->data();
    }
//! empty
/*
*  checks if queue is empty
*/
    bool empty() const {
        if (size_ == 0)
            return true;
        return false;
    }
//! size
/*
*  returns size of the queue
*/
    std::size_t size() const {
        return size_;
    }

 private:
    class Node {
     public:
        explicit Node(const T& data) {
            data_ = data;
            next_ = nullptr;
        }
        Node(const T& data, Node* next) {
            data_ = data;
            next_ = next;
        }
        T& data() {
            return data_;
        }
        const T& data() const {
            return data_;
        }

        Node* next() {
            return next_;
        }
        const Node* next() const {
            return next_;
        }

        void next(Node* node) {
            next_ = node;
        }

     private:
        T data_;
        Node* next_;
    };
    Node* head;  //  nodo-cabeça
    Node* tail;  //  nodo-fim
    std::size_t size_;  //  tamanho
};

}  //  namespace structures

#endif