Exemple de cache contigu

La manière la plus simple d’utiliser QContiguousCache consiste à 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, elle est également susceptible de demander des éléments situés à des 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 vérifie si celle-ci se trouve dans les limites de la plage actuelle du cache contigu. Il aurait tout aussi bien été possible d’utiliser 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 saute souvent des lignes si l'on utilise directement la barre de défilement, ce qui fait que le code ci-dessus entraîne la récupération de toutes les lignes situées 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 mémoire propre 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 pourraient encore être à l’écran ne sont pas perdus lorsque la ligne demandée ne s’est pas éloignée de la plage actuelle du cache. La fonction QContiguousCache::insert() peut potentiellement supprimer plus d’un élément du cache, car la fonction QContiguousCache ne tolère pas d’espaces vides. Si votre cache doit effectuer rapidement des allers-retours entre des lignes présentant des écarts importants, envisagez plutôt d'utiliser QCache.

Et voilà. Un cache tout à fait raisonnable, utilisant un minimum de mémoire pour une très grande liste. Dans ce cas, l’accesseur permettant d’intégrer 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 maintenue pour un nombre local de lignes lorsque vous exécutez l’exemple.

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

Il peut également être intéressant d’envisager de précharger des éléments dans le cache en dehors de la routine de rafraîchissement de l’application. Cela peut se faire soit à l’aide d’un thread distinct, soit en utilisant une fonction « QTimer » pour étendre progressivement la plage du cache avant que des lignes ne soient demandées en dehors de la plage actuelle du cache.

Exemple de projet sur code.qt.io