TrafficSimulator/linked_queue.h at master · AndreKuru/TrafficSimulator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#include <cstddef>
#include <stdexcept>

namespace structures {


template<typename T>

//! Fila encadeada
class LinkedQueue {
 public:
    LinkedQueue();

    ~LinkedQueue();

    //! limpar
    void clear();

    //! enfilerar
    void enqueue(const T& data);

    //! desenfilerar
    T dequeue();

    //! primeiro dado
    T& front() const;

    //! último dado
    T& back() const;

    //! fila vazia
    bool empty() const;

    //! tamanho
    std::size_t size() const;

 private:
    class Node {
     public:
        explicit Node(const T data):
                data_{data},
                next_{nullptr} {}

        Node(const T data, Node* next):
                data_{data},
                next_{next} {}

        //! getter data_
        T& data() {
            return data_;
        }

        //! getter next_
        Node* next() {
            return next_;
        }

        //! setter next_
        void next(Node* next) {
            next_ = next;
        }

     private:
        T data_;
        Node* next_;
    };  // Node

    //! nodo-cabeça
    Node* head = nullptr;

    //! nodo-fim
    Node* tail = nullptr;

    //! tamanho
    std::size_t size_ = 0;
};  // LinkedQueue

template<typename T>
LinkedQueue<T>::LinkedQueue() {}

template<typename T>
LinkedQueue<T>::~LinkedQueue() {
    clear();
}

template<typename T>
void LinkedQueue<T>::clear() {
    while (!empty()) {
        dequeue();
    }
}


template<typename T>
void LinkedQueue<T>::enqueue(const T &data) {
    if (empty()) {
        head = new Node(data);
        tail = head;
    } else {
        tail->next(new Node(data));
        tail = tail->next();
    }
    size_++;
}

template<typename T>
T LinkedQueue<T>::dequeue() {
    if (empty()) {
        throw std::out_of_range("Queue empty!");
    }
    auto it = *head;
    delete head;
    head = it.next();
    size_--;
    return it.data();
}

template<typename T>
T& LinkedQueue<T>::front() const {
    if (empty()) {
        throw std::out_of_range("Queue empty!");
    }
    return head->data();
}

template<typename T>
T& LinkedQueue<T>::back() const {
    if (empty()) {
        throw std::out_of_range("Queue empty!");
    }
    return tail->data();
}

template<typename T>
bool LinkedQueue<T>::empty() const {
    return size_ == 0;
}

template<typename T>
std::size_t LinkedQueue<T>::size() const {
    return size_;
}

}  // namespace structures