Beispiel für einen zusammenhängenden Cache

Die einfachste Art, QContiguousCache zu verwenden, ist die Zwischenspeicherung bei der Anforderung von Elementen. Wenn eine Ansicht ein Element in Zeile N anfordert, wird sie wahrscheinlich auch Elemente in Zeilen in der Nähe von N anfordern.

QVariant RandomListModel::data(const QModelIndex &index, int role) const{ if (role ! = Qt::DisplayRole) return QVariant(); int row = index.row(); if (row > m_rows.lastIndex()) { if (row - m_rows.lastIndex() > lookAhead) cacheRows(row - halfLookAhead, qMin(m_count, row + halfLookAhead)); else while (row > m_rows.lastIndex()) m_rows.append(fetchRow(m_rows.lastIndex() + 1)); } else if (row < m_rows.firstIndex()) { if (m_rows.firstIndex() - row > lookAhead)            cacheRows(qMax(0, row - halfLookAhead), row + halfLookAhead);
       else while (row < m_rows.firstIndex()) m_rows.prepend(fetchRow(m_rows.firstIndex() - 1)); } return m_rows.at(row); }void RandomListModel::cacheRows(int from, int to) const{ for(int i = from; i <= to;++i) m_rows.insert(i, fetchRow(i)); }

Nach dem Abrufen der Zeile stellt die Klasse fest, ob sich die Zeile innerhalb der Grenzen des aktuellen Bereichs des zusammenhängenden Cache befindet. Es wäre genauso gut möglich gewesen, stattdessen einfach den folgenden Code zu verwenden.

while (row > m_rows.lastIndex())
    m_rows.append(fetchWord(m_rows.lastIndex()+1);
while (row < m_rows.firstIndex())
    m_rows.prepend(fetchWord(m_rows.firstIndex()-1);

Eine Liste springt jedoch oft Zeilen, wenn die Bildlaufleiste direkt verwendet wird, was dazu führt, dass der obige Code jede Zeile zwischen der alten und der neuen Zeile abruft.

Durch die Verwendung von QContiguousCache::lastIndex() und QContiguousCache::firstIndex() kann das Beispiel feststellen, welchen Teil der Liste der Cache gerade zwischenspeichert. Diese Werte stellen nicht die Indizes im eigenen Speicher des Caches dar, sondern ein virtuelles unendliches Array, das der Cache repräsentiert.

Durch die Verwendung von QContiguousCache::append() und QContiguousCache::prepend() stellt der Code sicher, dass Elemente, die sich möglicherweise noch auf dem Bildschirm befinden, nicht verloren gehen, wenn sich die angeforderte Zeile nicht weit vom aktuellen Cache-Bereich entfernt hat. QContiguousCache::insert() kann unter Umständen mehr als ein Element aus dem Cache entfernen, da QContiguousCache keine Lücken zulässt. Wenn Ihr Cache schnell zwischen Zeilen mit großen Lücken dazwischen hin- und herspringen muss, sollten Sie stattdessen QCache verwenden.

Und das war's. Ein absolut vernünftiger Cache, der nur minimalen Speicher für eine sehr große Liste benötigt. In diesem Fall erzeugt der Accessor, der die Wörter in den Cache holt, eher zufällige als feste Informationen. So können Sie beim Ausführen des Beispiels sehen, wie der Cache-Bereich für eine lokale Anzahl von Zeilen gehalten wird.

QString RandomListModel::fetchRow(int position) const
{
    return QString::number(QRandomGenerator::global()->bounded(++position));
}

Es ist auch eine Überlegung wert, Elemente außerhalb der Paint-Routine der Anwendung in den Cache zu holen. Dies kann entweder mit einem separaten Thread oder unter Verwendung von QTimer geschehen, um den Bereich des Caches schrittweise zu erweitern, bevor Zeilen außerhalb des aktuellen Cache-Bereichs angefordert werden.

Beispielprojekt @ code.qt.io