js8call/JS8_Include/qpriorityqueue.h

/****************************************************************************
**
** Copyright (C) 2015 Corentin Chary <corentin.chary@gmail.cm>
**
** This file could be part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
** $QT_END_LICENSE$
**
****************************************************************************/

#ifndef QPRIORITY_QUEUE_H
#define QPRIORITY_QUEUE_H

#include <QtCore/qalgorithms.h>

QT_BEGIN_NAMESPACE

template <class T> class QList;

#ifndef QT_NO_STL
#include <queue>
#include <vector>
#else
/* Fallback class used when stl is not available */
template <class T, typename LessThan = std::less<T>>
class QPriorityQueuePrivate {
  public:
    inline QPriorityQueuePrivate(LessThan l) : lessThan(l), d() {}
    inline ~QPriorityQueuePrivate() {}

    inline void clear() { return d.clear(); }
    inline int size() const { return d.size(); }
    inline bool empty() const { return d.empty(); }

    inline T &top() { return d.front(); }

    void pop();
    void push(const T &value);

  private:
    inline int parent(int i) { return (i - 1) / 2; }
    inline int leftChild(int i) { return 2 * i + 1; }
    inline int rightChild(int i) { return 2 * i + 2; }

    LessThan lessThan;
    QList<T> d;
};
#endif

template <class T, typename LessThan = std::less<T>>
class Q_CORE_EXPORT QPriorityQueue {
  public:
    inline QPriorityQueue(LessThan l = std::less<T>())
        : lessThan(l), d(lessThan) {}
    inline QPriorityQueue(const QPriorityQueue<T> &q)
        : lessThan(q.lessThan), d(q.d) {}
    inline ~QPriorityQueue() {}

    QPriorityQueue<T> &operator=(const QPriorityQueue<T> &q) {
        d = q.d;
        return *this;
    }

    inline int size() const { return d.size(); }
    inline bool isEmpty() const { return empty(); }

    // like qlist
    void clear();
    void append(const T &t) { return enqueue(t); }
    void append(const QList<T> &t);
    T takeFirst() { return dequeue(); }
    inline int length() const { return size(); } // Same as count()
    inline T &first() { return head(); }
    inline const T &first() const { return head(); }
    inline void removeFirst() { pop(); }
    inline bool startsWith(const T &t) const {
        return !isEmpty() && first() == t;
    }

    // like qqueue
    inline void enqueue(const T &t) { push(t); }
    inline T dequeue() {
        T t = d.top();
        d.pop();
        return t;
    }
    inline T &head() { return const_cast<T &>(top()); }
    inline const T &head() const { return top(); }

    // stl compatibility
    typedef int size_type;
    typedef T value_type;

    inline bool empty() const { return d.empty(); }
    inline const value_type &top() {
        Q_ASSERT(!isEmpty());
        return d.top();
    }
    inline void push(const value_type &x) { return d.push(x); }
    inline void pop() {
        Q_ASSERT(!isEmpty());
        d.pop();
    }

    // comfort
    inline QPriorityQueue<T> &operator+=(const T &t) {
        enqueue(t);
        return *this;
    }
    inline QPriorityQueue<T> &operator<<(const T &t) {
        enqueue(t);
        return *this;
    }
    inline QPriorityQueue<T> &operator>>(T &t) {
        t = d.top();
        d.pop();
        return *this;
    }

#ifndef QT_NO_STL
    static inline QPriorityQueue<T>
    fromStdPriorityQueue(const std::priority_queue<T> &q) {
        QPriorityQueue<T> tmp;
        tmp.d = q;
        return tmp;
    }
    inline std::priority_queue<T> toStdPriorityQueue() const { return d; }
#endif

  private:
    LessThan lessThan;
#ifndef QT_NO_STL
    std::priority_queue<T, std::vector<T>, LessThan> d;
#else
    QPriorityQueuePrivate<T> d;
#endif
};

#ifndef QT_NO_STL

template <typename T, typename LessThan>
Q_INLINE_TEMPLATE void QPriorityQueue<T, LessThan>::clear() {
    d = std::priority_queue<T, std::vector<T>, LessThan>(lessThan);
    // d = std::priority_queue<T>(lessThan);
}

#else

template <typename T, typename LessThan>
Q_INLINE_TEMPLATE void QPriorityQueue<T, LessThan>::clear() {
    d.clear();
}

#endif

template <typename T, typename LessThan>
Q_OUTOFLINE_TEMPLATE void
QPriorityQueue<T, LessThan>::append(const QList<T> &t) {
    foreach (T &e, t)
        push(e);
}

// Re-implement std::priority_queue if STL not available, probably
// less efficient.
#ifdef QT_NO_STL
/*!
 *  Pop an element from the queue and reorder it using an
 *  inlined binary heap.
 *
 *  \internal
 */
template <typename T, typename LessThan>
Q_OUTOFLINE_TEMPLATE void QPriorityQueuePrivate<T, LessThan>::pop() {
    int i = 0;
    ssize_t size = d.size();
    ;

    if (!size)
        return;
    if (size == 1)
        return d.clear();

    d[0] = d.takeLast();

    while (i < size - 1) {
        int left = leftChild(i);
        int right = rightChild(i);
        bool validLeft = left < size;
        bool validRight = right < size;

        if (validLeft && lessThan(d.at(i), d.at(left)))
            if (validRight && !lessThan(d.at(right), d.at(left))) {
                d.swap(i, right);
                i = right;
            } else {
                d.swap(i, left);
                i = left;
            }
        else if (validRight && lessThan(d.at(i), d.at(right))) {
            d.swap(i, right);
            i = right;
        } else
            break;
    }
}

/*!
 *  Push an element with a given priority to the right place.
 *
 *  \internal
 */
template <typename T, typename LessThan>
Q_OUTOFLINE_TEMPLATE void
QPriorityQueuePrivate<T, LessThan>::push(const T &value) {
    int i = d.size();
    d.append(value);
    while (i != 0 && !lessThan(d.at(i), d.at(parent(i)))) {
        d.swap(i, parent(i));
        i = parent(i);
    }
}
#endif

QT_END_NAMESPACE

#endif // QPRIORITY_QUEUE_H