ksortablelist.h

/* This file is part of the KDE libraries
    Copyright (C) 2001 Carsten Pfeiffer <[email protected]>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef KSORTABLELIST_H
#define KSORTABLELIST_H

#include <kcompletion_export.h>

#include <QPair>
#include <QList>
#include <algorithm>

template<typename T, typename Key = int> class KSortableItem : public QPair<Key, T>
{
public:
    KSortableItem(Key i, const T &t) : QPair<Key, T>(i, t) {}
    KSortableItem(const KSortableItem<T, Key> &rhs)
        : QPair<Key, T>(rhs.first, rhs.second) {}

    KSortableItem() {}

    KSortableItem<T, Key> &operator=(const KSortableItem<T, Key> &i)
    {
        this->first  = i.first;
        this->second = i.second;
        return *this;
    }

    // operators for sorting
    bool operator> (const KSortableItem<T, Key> &i2) const
    {
        return (i2.first < this->first);
    }
    bool operator< (const KSortableItem<T, Key> &i2) const
    {
        return (this->first < i2.first);
    }
    bool operator>= (const KSortableItem<T, Key> &i2) const
    {
        return (this->first >= i2.first);
    }
    bool operator<= (const KSortableItem<T, Key> &i2) const
    {
        return !(i2.first < this->first);
    }
    bool operator== (const KSortableItem<T, Key> &i2) const
    {
        return (this->first == i2.first);
    }
    bool operator!= (const KSortableItem<T, Key> &i2) const
    {
        return (this->first != i2.first);
    }

    T &value()
    {
        return this->second;
    }

    const T &value() const
    {
        return this->second;
    }

#if KCOMPLETION_ENABLE_DEPRECATED_SINCE(4, 0)

    KCOMPLETION_DEPRECATED_VERSION(4, 0, "Use KSortableItem::key()")
    Key index() const
    {
        return this->first;
    }
#endif

    Key key() const
    {
        return this->first;
    }
};

template <typename T, typename Key = int>
class KSortableList : public QList<KSortableItem<T, Key> >
{
public:
    void insert(Key i, const T &t)
    {
        QList<KSortableItem<T, Key> >::append(KSortableItem<T, Key>(i, t));
    }
    // add more as you please...

    T &operator[](Key i)
    {
        return QList<KSortableItem<T, Key> >::operator[](i).value();
    }

    const T &operator[](Key i) const
    {
        return QList<KSortableItem<T, Key> >::operator[](i).value();
    }

    void sort()
    {
        std::sort(this->begin(), this->end());
    }
};

#ifdef Q_CC_MSVC
template<class T, class K>
inline uint qHash(const KSortableItem<T, K> &)
{
    Q_ASSERT(0);
    return 0;
}
#endif

#endif // KSORTABLELIST_H