mythdeque.h

Go to the documentation of this file.

// -*- Mode: c++ -*-

#ifndef __MYTH_DEQUE_H__
#define __MYTH_DEQUE_H__

#include <QString>
#include <QStringList>
#include <deque>
using std::deque;

template<typename T>
inline T myth_deque_init(const T */*unused*/) { return nullptr; }
template<>
inline int myth_deque_init(const int * /*unused*/) { return 0; }
template<>
inline uint myth_deque_init(const uint * /*unused*/) { return 0; }
template<>
inline QString myth_deque_init(const QString * /*unused*/) { return QString(); }
template<>
inline QStringList myth_deque_init(const QStringList * /*unused*/) { return QStringList(); }

template<typename T>
class MythDeque : public deque<T>
{
  public:
    T dequeue()
    {
        T *dummy = nullptr;
        if (deque<T>::empty())
            return myth_deque_init(dummy);
        T item = deque<T>::front();
        deque<T>::pop_front();
        return item;
    }
    void enqueue(T d) { deque<T>::push_back(d); }

    using iterator = typename deque<T>::iterator;
    using const_iterator = typename deque<T>::const_iterator;
    using size_type = typename deque<T>::size_type;

    iterator find(T const item)
    {
        for (auto it = deque<T>::begin(); it != deque<T>::end(); ++it)
            if (*it == item)
                return it;
        return deque<T>::end();
    }

    const_iterator find(T const item) const
    {
        for (auto it = deque<T>::begin(); it != deque<T>::end(); ++it)
            if (*it == item)
                return it;
        return deque<T>::end();
    }

    void remove(T const item)
    {
        auto it = find(item);
        if (it != deque<T>::end())
            deque<T>::erase(it);
    }

    bool contains(T const &item) const
        { return find(item) != deque<T>::end(); }

    size_type count() const { return deque<T>::size(); }

    T head()
        { if (!deque<T>::empty()) return deque<T>::front();
          T *dummy = nullptr; return myth_deque_init(dummy); }
    T head() const
        { if (!deque<T>::empty()) return deque<T>::front();
          T *dummy = NULL; return myth_deque_init(dummy); }

    T tail()
        { if (!deque<T>::empty()) return deque<T>::back();
          T *dummy = nullptr; return myth_deque_init(dummy); }
    const T tail() const
        { if (!deque<T>::empty()) return deque<T>::back();
          T *dummy = NULL; return myth_deque_init(dummy); }
};

#endif // __MYTH_DEQUE_H__