Method processFetchQueue

syncthingmodel/syncthingfilemodel.cpp:1066–1173

}

void SyncthingFileModel::processFetchQueue(const QString &lastItemPath)
{
    if (!lastItemPath.isNull()) {
        m_fetchQueue.removeAll(lastItemPath);
    }
    if (m_fetchQueue.isEmpty()) {
        emit fetchQueueEmpty();
        return;
    }
    const auto &path = m_fetchQueue.front();
    const auto rootIndex = index(path);
    if (!rootIndex.isValid()) {
        processFetchQueue(path);
        return;
    }

    // add/update loading item
    auto *rootItem = reinterpret_cast<SyncthingItem *>(rootIndex.internalPointer());
    const auto populated = rootItem->childrenPopulated;
    if (!rootItem->childrenPopulated) {
        rootItem->childrenPopulated = true;
        switch (rootItem->children.size()) {
        case 0:
            beginInsertRows(rootIndex, 0, 0);
            addLoadingItem(rootItem->children);
            endInsertRows();
            break;
        case 1:
            setLoadingItem(rootItem->children.front().get());
            const auto affectedIndex = index(0, 0, rootIndex);
            emit dataChanged(affectedIndex, affectedIndex, QVector<int>{ Qt::DisplayRole, Qt::DecorationRole });
            break;
        }
    }

    // query directory entries from Syncthing database
    if (rootItem->existsInDb.value_or(false)) {
        m_pendingRequest = m_connection.browse(
            m_dirId, path, 1, [this, populated](std::vector<std::unique_ptr<SyncthingItem>> &&items, QString &&errorMessage) mutable {
                m_pendingRequest.reply = nullptr;
                addErrorItem(items, std::move(errorMessage));
                const auto refreshedIndex = index(m_pendingRequest.forPath);

                if (!refreshedIndex.isValid()) {
                    processFetchQueue(m_pendingRequest.forPath);
                    return;
                }
                auto *const refreshedItem = reinterpret_cast<SyncthingItem *>(refreshedIndex.internalPointer());
                const auto previousChildCount = refreshedItem->children.size();
                if (previousChildCount) {
                    beginRemoveRows(refreshedIndex, 0, static_cast<int>(refreshedItem->children.size() - 1));
                    refreshedItem->children.clear();
                    endRemoveRows();
                }
                if (!items.empty()) {
                    const auto last = items.size() - 1;
                    for (auto &item : items) {
                        item->parent = refreshedItem;