Queue.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/SList.h>
#include <ogdf/basic/memory.h>
 
#include <initializer_list>
#include <iosfwd>
#include <utility>
 
namespace ogdf {
 
 
 
template<class E>
class QueuePure : private SListPure<E> {
public:
    using value_type = E;
    using reference = E&;
    using const_reference = const E&;
    using const_iterator = SListConstIterator<E>;
    using iterator = SListIterator<E>;
 
    QueuePure() { }
 
    QueuePure(std::initializer_list<E> initList) : SListPure<E>(initList) { }
 
    QueuePure(const QueuePure<E>& Q) : SListPure<E>(Q) { }
 
 
    QueuePure(QueuePure<E>&& Q) : SListPure<E>(std::move(Q)) { }
 
    ~QueuePure() { }
 
 
    bool empty() const { return SListPure<E>::empty(); }
 
    const_reference top() const { return SListPure<E>::front(); }
 
    reference top() { return SListPure<E>::front(); }
 
    const_reference bottom() const { return SListPure<E>::back(); }
 
    reference bottom() { return SListPure<E>::back(); }
 
 
 
    iterator begin() { return SListPure<E>::begin(); }
 
    const_iterator begin() const { return SListPure<E>::begin(); }
 
    const_iterator cbegin() const { return SListPure<E>::cbegin(); }
 
    iterator end() { return SListPure<E>::end(); }
 
    const_iterator end() const { return SListPure<E>::end(); }
 
    const_iterator cend() const { return SListPure<E>::cend(); }
 
    iterator backIterator() { return SListPure<E>::backIterator(); }
 
    const_iterator backIterator() const { return SListPure<E>::backIterator(); }
 
 
 
    QueuePure<E>& operator=(const QueuePure<E>& Q) {
        SListPure<E>::operator=(Q);
        return *this;
    }
 
 
    QueuePure<E>& operator=(QueuePure<E>&& Q) {
        SListPure<E>::operator=(std::move(Q));
        return *this;
    }
 
    const SListPure<E>& getListPure() const { return *this; }
 
 
 
    iterator append(const E& x) { return SListPure<E>::pushBack(x); }
 
 
    template<class... Args>
    iterator emplace(Args&&... args) {
        return SListPure<E>::emplaceBack(std::forward<Args>(args)...);
    }
 
    E pop() {
        E x = top();
        SListPure<E>::popFront();
        return x;
    }
 
    void clear() { SListPure<E>::clear(); }
 
    OGDF_NEW_DELETE
};
 
 
template<class E>
class Queue : private SList<E> {
public:
    using value_type = E;
    using reference = E&;
    using const_reference = const E&;
    using const_iterator = SListConstIterator<E>;
    using iterator = SListIterator<E>;
 
    Queue() { }
 
    Queue(std::initializer_list<E> initList) : SList<E>(initList) { }
 
    Queue(const Queue<E>& Q) : SList<E>(Q) { }
 
 
    Queue(Queue<E>&& Q) : SList<E>(std::move(Q)) { }
 
    ~Queue() { }
 
 
    bool empty() const { return SList<E>::empty(); }
 
    int size() const { return SList<E>::size(); }
 
    const_reference top() const { return SList<E>::front(); }
 
    reference top() { return SList<E>::front(); }
 
    const_reference bottom() const { return SListPure<E>::back(); }
 
    reference bottom() { return SListPure<E>::back(); }
 
 
 
    iterator begin() { return SList<E>::begin(); }
 
    const_iterator begin() const { return SList<E>::begin(); }
 
    const_iterator cbegin() const { return SList<E>::cbegin(); }
 
    iterator end() { return SList<E>::end(); }
 
    const_iterator end() const { return SList<E>::end(); }
 
    const_iterator cend() const { return SList<E>::cend(); }
 
    iterator backIterator() { return SList<E>::backIterator(); }
 
    const_iterator backIterator() const { return SList<E>::backIterator(); }
 
 
 
    Queue<E>& operator=(const Queue<E>& Q) {
        SList<E>::operator=(Q);
        return *this;
    }
 
 
    Queue<E>& operator=(Queue<E>&& Q) {
        SList<E>::operator=(std::move(Q));
        return *this;
    }
 
    const SList<E>& getList() const { return *this; }
 
 
 
    iterator append(const E& x) { return SList<E>::pushBack(x); }
 
 
    template<class... Args>
    iterator emplace(Args&&... args) {
        return SList<E>::emplaceBack(std::forward<Args>(args)...);
    }
 
    E pop() {
        E x = top();
        SList<E>::popFront();
        return x;
    }
 
    void clear() { SList<E>::clear(); }
 
 
    OGDF_NEW_DELETE
};
 
// prints queue to output stream os using delimiter delim
template<class E>
void print(std::ostream& os, const QueuePure<E>& Q, char delim = ' ') {
    print(os, Q.getListPure(), delim);
}
 
// prints queue to output stream os using delimiter delim
template<class E>
void print(std::ostream& os, const Queue<E>& Q, char delim = ' ') {
    print(os, Q.getList(), delim);
}
 
// output operator
template<class E>
std::ostream& operator<<(std::ostream& os, const QueuePure<E>& Q) {
    print(os, Q);
    return os;
}
 
template<class E>
std::ostream& operator<<(std::ostream& os, const Queue<E>& Q) {
    print(os, Q);
    return os;
}
 
}