SimpleQueue.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_SIMPLEQUEUE_HXX_
#define _UTILS_SIMPLEQUEUE_HXX_
 
#include "utils/QMember.hxx"
 
class SimpleQueue {
public:
    SimpleQueue() : head_(nullptr) {}
 
    bool empty() {
        return !head_;
    }
 
    void push_front(QMember* member) {
        HASSERT(!member->next);
        member->next = head_;
        head_ = member;
    }
 
    QMember* pop_front() {
        HASSERT(head_);
        QMember* f = head_;
        head_ = f->next;
        f->next = nullptr;
        return f;
    }
 
    QMember* front() const {
        return head_;
    }
 
    class end_iterator {};
 
    class iterator {
    public:
        iterator(QMember** link): link_(link) {
            HASSERT(link_);
        }
 
        bool operator==(const iterator& o) const {
            return *link_ == *o.link_;
        }
 
        bool operator==(const end_iterator& o) const {
            return *link_ == nullptr;
        }
 
        bool operator!=(const iterator& o) const {
            return *link_ != *o.link_;
        }
 
        bool operator!=(const end_iterator& o) const {
            return *link_ != nullptr;
        }
 
        iterator& operator++() {
            HASSERT(*link_);
            link_ = &(*link_)->next;
            return *this;
        }
 
        QMember* operator->() {
            return *link_;
        }
 
        QMember& operator*() {
            return **link_;
        }
 
    private:
        friend class SimpleQueue;
 
        QMember** link_;
    };
 
    template<class T> class typed_iterator : public iterator {
    public:
        typed_iterator(QMember** link): iterator(link) {}
        T* operator->() {
            return static_cast<T*>(*link_);
        }
        T& operator*() {
            return static_cast<T&>(**link_);
        }
    };
 
    iterator begin() {
        return iterator(&head_);
    }
 
    end_iterator end() {
        return end_iterator{};
    }
 
    void insert(const iterator& position, QMember* entry) {
        HASSERT(!entry->next);
        entry->next = *position.link_;
        *position.link_ = entry;
    }
 
    void erase(const iterator& position) {
        QMember* m = *position.link_;
        HASSERT(m);
        *position.link_ = m->next;
        m->next = nullptr;
    }
 
protected:
    static QMember* const PTR_END;
 
    QMember* head_;
};
 
 
template<class T>
class TypedQueue : public SimpleQueue {
public:
    void push_front(T* entry) {
        SimpleQueue::push_front(entry);
    }
 
    T* pop_front() {
        return static_cast<T*>(SimpleQueue::pop_front());
    }
 
    T* front() const {
        return static_cast<T*>(SimpleQueue::front());
    }
 
    typedef typed_iterator<T> iterator;
 
    iterator begin() {
        return iterator(&head_);
    }
};
 
#endif // _UTILS_SIMPLEQUEUE_HXX_