QSortedModelEngine Class Reference

#include <qcompleter_p.h>

Inheritance diagram for QSortedModelEngine:

Public Functions
QMatchData	filter (const QString &, const QModelIndex &, int)
QIndexMapper	indexHint (QString, const QModelIndex &, Qt::SortOrder)
	QSortedModelEngine (QCompleterPrivate *c)
Qt::SortOrder	sortOrder (const QModelIndex &) const
Public Functions inherited from QCompletionEngine
void	filter (const QStringList &parts)
QMatchData	filterHistory ()
virtual void	filterOnDemand (int)
bool	lookupCache (QString part, const QModelIndex &parent, QMatchData *m)
int	matchCount () const
bool	matchHint (QString, const QModelIndex &, QMatchData *)
	QCompletionEngine (QCompleterPrivate *c)
void	saveInCache (QString, const QModelIndex &, const QMatchData &)
virtual	~QCompletionEngine ()

Additional Inherited Members
Public Types inherited from QCompletionEngine
typedef QMap< QModelIndex, CacheItem >	Cache
typedef QMap< QString, QMatchData >	CacheItem
Public Variables inherited from QCompletionEngine
QCompleterPrivate *	c
Cache	cache
int	cost
QMatchData	curMatch
QModelIndex	curParent
QStringList	curParts
int	curRow
QMatchData	historyMatch

Detailed Description

Definition at line 173 of file qcompleter_p.h.

Constructors and Destructors

QSortedModelEngine()

QSortedModelEngine::QSortedModelEngine ( QCompleterPrivate *  c )

inline

Definition at line 176 of file qcompleter_p.h.

: QCompletionEngine(c) { }

Functions

filter()

QMatchData QSortedModelEngine::filter ( const QString &  part, const QModelIndex &  parent, int    )

virtual

Implements QCompletionEngine.

Definition at line 620 of file qcompleter.cpp.

{
    const QAbstractItemModel *model = c->proxy->sourceModel();

    QMatchData hint;
    if (lookupCache(part, parent, &hint))
        return hint;

    QIndexMapper indices;
    Qt::SortOrder order = sortOrder(parent);

    if (matchHint(part, parent, &hint)) {
        if (!hint.isValid())
            return QMatchData();
        indices = hint.indices;
    } else {
        indices = indexHint(part, parent, order);
    }

    // binary search the model within 'indices' for 'part' under 'parent'
    int high = indices.to() + 1;
    int low = indices.from() - 1;
    int probe;
    QModelIndex probeIndex;
    QString probeData;

    while (high - low > 1)
    {
        probe = (high + low) / 2;
        probeIndex = model->index(probe, c->column, parent);
        probeData = model->data(probeIndex, c->role).toString();
        const int cmp = QString::compare(probeData, part, c->cs);
        if ((order == Qt::AscendingOrder && cmp >= 0)
            || (order == Qt::DescendingOrder && cmp < 0)) {
            high = probe;
        } else {
            low = probe;
        }
    }

    if ((order == Qt::AscendingOrder && low == indices.to())
        || (order == Qt::DescendingOrder && high == indices.from())) { // not found
        saveInCache(part, parent, QMatchData());
        return QMatchData();
    }

    probeIndex = model->index(order == Qt::AscendingOrder ? low+1 : high-1, c->column, parent);
    probeData = model->data(probeIndex, c->role).toString();
    if (!probeData.startsWith(part, c->cs)) {
        saveInCache(part, parent, QMatchData());
        return QMatchData();
    }

    const bool exactMatch = QString::compare(probeData, part, c->cs) == 0;
    int emi =  exactMatch ? (order == Qt::AscendingOrder ? low+1 : high-1) : -1;

    int from = 0;
    int to = 0;
    if (order == Qt::AscendingOrder) {
        from = low + 1;
        high = indices.to() + 1;
        low = from;
    } else {
        to = high - 1;
        low = indices.from() - 1;
        high = to;
    }

    while (high - low > 1)
    {
        probe = (high + low) / 2;
        probeIndex = model->index(probe, c->column, parent);
        probeData = model->data(probeIndex, c->role).toString();
        const bool startsWith = probeData.startsWith(part, c->cs);
        if ((order == Qt::AscendingOrder && startsWith)
            || (order == Qt::DescendingOrder && !startsWith)) {
            low = probe;
        } else {
            high = probe;
        }
    }

    QMatchData m(order == Qt::AscendingOrder ? QIndexMapper(from, high - 1) : QIndexMapper(low+1, to), emi, false);
    saveInCache(part, parent, m);
    return m;
}

indexHint()

QIndexMapper QSortedModelEngine::indexHint	(	QString	part,
		const QModelIndex &	parent,
		Qt::SortOrder	order
	)

Definition at line 565 of file qcompleter.cpp.

{
    const QAbstractItemModel *model = c->proxy->sourceModel();

    if (c->cs == Qt::CaseInsensitive)
        part = part.toLower();

    const CacheItem& map = cache[parent];

    // Try to find a lower and upper bound for the search from previous results
    int to = model->rowCount(parent) - 1;
    int from = 0;
    const CacheItem::const_iterator it = map.lowerBound(part);

    // look backward for first valid hint
    for(CacheItem::const_iterator it1 = it; it1-- != map.constBegin();) {
        const QMatchData& value = it1.value();
        if (value.isValid()) {
            if (order == Qt::AscendingOrder) {
                from = value.indices.last() + 1;
            } else {
                to = value.indices.first() - 1;
            }
            break;
        }
    }

    // look forward for first valid hint
    for(CacheItem::const_iterator it2 = it; it2 != map.constEnd(); ++it2) {
        const QMatchData& value = it2.value();
        if (value.isValid() && !it2.key().startsWith(part)) {
            if (order == Qt::AscendingOrder) {
                to = value.indices.first() - 1;
            } else {
                from = value.indices.first() + 1;
            }
            break;
        }
    }

    return QIndexMapper(from, to);
}

sortOrder()

Qt::SortOrder QSortedModelEngine::sortOrder

(

const QModelIndex &

parent

)

const

Definition at line 608 of file qcompleter.cpp.

{
    const QAbstractItemModel *model = c->proxy->sourceModel();

    int rowCount = model->rowCount(parent);
    if (rowCount < 2)
        return Qt::AscendingOrder;
    QString first = model->data(model->index(0, c->column, parent), c->role).toString();
    QString last = model->data(model->index(rowCount - 1, c->column, parent), c->role).toString();
    return QString::compare(first, last, c->cs) <= 0 ? Qt::AscendingOrder : Qt::DescendingOrder;
}

---

The documentation for this class was generated from the following files:

• /src/gui/util/qcompleter_p.h
• /src/gui/util/qcompleter.cpp