SimpleList.h

Go to the documentation of this file.

#ifndef SIMPLE_LIST_H
#define SIMPLE_LIST_H
 
 
template<typename T>
class SimpleList {
private:
    struct Node {
        T data;     
        Node* next; 
 
        Node(const T& value) : data(value), next(nullptr) {}
    };
 
    Node* head;           
    Node* tail;           
    mutable Node* read_position;  
    size_t size;          
 
public:
    SimpleList() : head(nullptr), tail(nullptr), read_position(nullptr), size(0) {}
 
    ~SimpleList() {
        clear();
    }
 
    void push_back(const T& value) {
        Node* new_node = new Node(value);
        if (!head) {
            head = tail = read_position = new_node;
        } else {
            tail->next = new_node;
            tail = new_node;
        }
        ++size;
    }
 
    void pop_front() {
        if (head) {
            Node* temp = head;
            head = head->next;
            if (read_position == temp) {
                read_position = head;
            }
            delete temp;
            --size;
            if (!head) {
                tail = nullptr;
                read_position = nullptr;
            }
        }
    }
 
    T read() const {
        if (read_position) {
            T value = read_position->data;
            read_position = read_position->next;
            return value;
        }
        return T();  // Return empty T
    }
 
    void rewind() const {
        read_position = head;
    }
 
    bool is_exhausted() const {
        return read_position == nullptr;
    }
 
    size_t get_size() const {
        return size;
    }
 
    void clear() {
        while (head) {
            Node* temp = head;
            head = head->next;
            delete temp;
        }
        tail = nullptr;
        read_position = nullptr;
        size = 0;
    }
 
    class const_iterator {
    private:
        const Node* current; 
 
    public:
        const_iterator() : current(nullptr) {}
 
        explicit const_iterator(const Node* node) : current(node) {}
 
        const T& operator*() const { return current->data; }
 
        const T* operator->() const { return &current->data; }
 
        const_iterator& operator++() { if (current) current = current->next; return *this; }
 
        const_iterator operator++(int) { const_iterator tmp = *this; ++(*this); return tmp; }
 
        bool operator!=(const const_iterator& other) const { return current != other.current; }
 
        bool operator==(const const_iterator& other) const { return current == other.current; }
    };
 
    const_iterator cbegin() const { return const_iterator(head); }
 
    const_iterator cend() const { return const_iterator(nullptr); }
 
    class iterator {
    private:
        Node* current; 
 
    public:
        iterator() : current(nullptr) {}
 
        iterator(Node* node) : current(node) {}
 
        T& operator*() { return current->data; }
 
        T* operator->() { return &current->data; }
 
        iterator& operator++() { if (current) current = current->next; return *this; }
 
        bool operator!=(const iterator& other) const { return current != other.current; }
 
        bool operator==(const iterator& other) const { return current == other.current; }
    };
 
    iterator begin() const { return iterator(head); }
 
    iterator end() const { return iterator(nullptr); }
};
 
#endif // SIMPLE_LIST_H