Exemple de cache contigu

La manière la plus simple d'utiliser QContiguousCache est de mettre en cache les éléments au fur et à mesure qu'ils sont demandés. Lorsqu'une vue demande un élément à la ligne N, il est probable qu'elle demande également des éléments aux lignes proches de N.

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)) ; }

Après avoir récupéré la ligne, la classe détermine si elle se trouve dans les limites de la plage actuelle du cache contigu. Il aurait été tout aussi valable d'avoir simplement le code suivant à la place.

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);

Cependant, une liste sautera souvent des lignes si la barre de défilement est utilisée directement, ce qui fait que le code ci-dessus récupère toutes les lignes entre l'ancienne et la nouvelle ligne.

L'utilisation de QContiguousCache::lastIndex() et QContiguousCache::firstIndex() permet à l'exemple de déterminer quelle partie de la liste est actuellement mise en cache. Ces valeurs ne représentent pas les index dans la propre mémoire du cache, mais plutôt un tableau virtuel infini que le cache représente.

En utilisant QContiguousCache::append() et QContiguousCache::prepend(), le code garantit que les éléments qui peuvent être encore à l'écran ne sont pas perdus lorsque la ligne demandée ne s'est pas éloignée de la plage actuelle du cache. QContiguousCache::insert() peut potentiellement supprimer plus d'un élément de la mémoire cache, car QContiguousCache ne permet pas les écarts. Si votre cache doit passer rapidement d'une ligne à l'autre avec des espaces importants entre elles, utilisez plutôt QCache.

Et c'est tout. Un cache parfaitement raisonnable, utilisant un minimum de mémoire pour une très grande liste. Dans ce cas, l'accesseur permettant d'introduire les mots dans le cache génère des informations aléatoires plutôt que des informations fixes. Cela vous permet de voir comment la plage du cache est conservée pour un nombre local de lignes lors de l'exécution de l'exemple.

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

Il est également intéressant d'envisager de prélever des éléments dans le cache en dehors de la routine de peinture de l'application. Cela peut se faire soit avec un thread séparé, soit en utilisant QTimer pour étendre de manière incrémentale la plage du cache avant que des lignes ne soient demandées en dehors de la plage actuelle du cache.

Exemple de projet @ code.qt.io