File indexing completed on 2025-01-05 04:46:24

 /*
     SPDX-FileCopyrightText: 2012 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "collectionfetchjob.h"
 #include "collectionfetchscope.h"
 #include "itemfetchjob.h"
 #include "itemfetchscope.h"
 #include "recursivemover_p.h"
 
 using namespace Akonadi;
 
 RecursiveMover::RecursiveMover(AgentBasePrivate *parent)
     : KCompositeJob(parent)
     , m_agentBase(parent)
     , m_currentAction(None)
 {
 }
 
 void RecursiveMover::start()
 {
     Q_ASSERT(receivers(SIGNAL(result(KJob *))));
 
     auto job = new CollectionFetchJob(m_movedCollection, CollectionFetchJob::Recursive, this);
     connect(job, &CollectionFetchJob::finished, this, &RecursiveMover::collectionListResult);
     addSubjob(job);
     ++m_runningJobs;
 }
 
 void RecursiveMover::setCollection(const Collection &collection, const Collection &parentCollection)
 {
     m_movedCollection = collection;
     m_collections.insert(collection.id(), m_movedCollection);
     m_collections.insert(parentCollection.id(), parentCollection);
 }
 
 void RecursiveMover::collectionListResult(KJob *job)
 {
     Q_ASSERT(m_pendingCollections.isEmpty());
     --m_runningJobs;
 
     if (job->error()) {
         return; // error handling is in the base class
     }
 
     // build a parent -> children map for the following topological sorting
     // while we are iterating anyway, also fill m_collections here
     auto fetchJob = qobject_cast<CollectionFetchJob *>(job);
     QHash<Collection::Id, Collection::List> colTree;
     const Akonadi::Collection::List lstCol = fetchJob->collections();
     for (const Collection &col : lstCol) {
         colTree[col.parentCollection().id()] << col;
         m_collections.insert(col.id(), col);
     }
 
     // topological sort; BFS traversal of the tree
     m_pendingCollections.push_back(m_movedCollection);
     QQueue<Collection> toBeProcessed;
     toBeProcessed.enqueue(m_movedCollection);
     while (!toBeProcessed.isEmpty()) {
         const Collection col = toBeProcessed.dequeue();
         const Collection::List children = colTree.value(col.id());
         if (children.isEmpty()) {
             continue;
         }
         m_pendingCollections += children;
         for (const Collection &child : children) {
             toBeProcessed.enqueue(child);
         }
     }
 
     replayNextCollection();
 }
 
 void RecursiveMover::collectionFetchResult(KJob *job)
 {
     Q_ASSERT(m_currentCollection.isValid());
     --m_runningJobs;
 
     if (job->error()) {
         return; // error handling is in the base class
     }
 
     auto fetchJob = qobject_cast<CollectionFetchJob *>(job);
     if (fetchJob->collections().size() == 1) {
         m_currentCollection = fetchJob->collections().at(0);
         m_currentCollection.setParentCollection(m_collections.value(m_currentCollection.parentCollection().id()));
         m_collections.insert(m_currentCollection.id(), m_currentCollection);
     } else {
         // already deleted, move on
     }
 
     if (!m_runningJobs && m_pendingReplay) {
         replayNext();
     }
 }
 
 void RecursiveMover::itemListResult(KJob *job)
 {
     --m_runningJobs;
 
     if (job->error()) {
         return; // error handling is in the base class
     }
     const Akonadi::Item::List lstItems = qobject_cast<ItemFetchJob *>(job)->items();
     for (const Item &item : lstItems) {
         if (item.remoteId().isEmpty()) {
             m_pendingItems.push_back(item);
         }
     }
 
     if (!m_runningJobs && m_pendingReplay) {
         replayNext();
     }
 }
 
 void RecursiveMover::itemFetchResult(KJob *job)
 {
     Q_ASSERT(m_currentAction == None);
     --m_runningJobs;
 
     if (job->error()) {
         return; // error handling is in the base class
     }
 
     auto fetchJob = qobject_cast<ItemFetchJob *>(job);
     if (fetchJob->items().size() == 1) {
         m_currentAction = AddItem;
         m_agentBase->itemAdded(fetchJob->items().at(0), m_currentCollection);
     } else {
         // deleted since we started, skip
         m_currentItem = Item();
         replayNextItem();
     }
 }
 
 void RecursiveMover::replayNextCollection()
 {
     if (!m_pendingCollections.isEmpty()) {
         m_currentCollection = m_pendingCollections.takeFirst();
         auto job = new ItemFetchJob(m_currentCollection, this);
         connect(job, &ItemFetchJob::result, this, &RecursiveMover::itemListResult);
         addSubjob(job);
         ++m_runningJobs;
 
         if (m_currentCollection.remoteId().isEmpty()) {
             Q_ASSERT(m_currentAction == None);
             m_currentAction = AddCollection;
             m_agentBase->collectionAdded(m_currentCollection, m_collections.value(m_currentCollection.parentCollection().id()));
             return;
         } else {
             // replayNextItem(); - but waiting for the fetch job to finish first
             m_pendingReplay = true;
             return;
         }
     } else {
         // nothing left to do
         emitResult();
     }
 }
 
 void RecursiveMover::replayNextItem()
 {
     Q_ASSERT(m_currentCollection.isValid());
     if (m_pendingItems.isEmpty()) {
         replayNextCollection(); // all items processed here
         return;
     } else {
         Q_ASSERT(m_currentAction == None);
         m_currentItem = m_pendingItems.takeFirst();
         auto job = new ItemFetchJob(m_currentItem, this);
         job->fetchScope().fetchFullPayload();
         connect(job, &ItemFetchJob::result, this, &RecursiveMover::itemFetchResult);
         addSubjob(job);
         ++m_runningJobs;
     }
 }
 
 void RecursiveMover::changeProcessed()
 {
     Q_ASSERT(m_currentAction != None);
 
     if (m_currentAction == AddCollection) {
         Q_ASSERT(m_currentCollection.isValid());
         auto job = new CollectionFetchJob(m_currentCollection, CollectionFetchJob::Base, this);
         job->fetchScope().setAncestorRetrieval(CollectionFetchScope::All);
         connect(job, &CollectionFetchJob::result, this, &RecursiveMover::collectionFetchResult);
         addSubjob(job);
         ++m_runningJobs;
     }
 
     m_currentAction = None;
 }
 
 void RecursiveMover::replayNext()
 {
     // wait for runnings jobs to finish before actually doing the replay
     if (m_runningJobs) {
         m_pendingReplay = true;
         return;
     }
 
     m_pendingReplay = false;
 
     if (m_currentCollection.isValid()) {
         replayNextItem();
     } else {
         replayNextCollection();
     }
 }
 
 #include "moc_recursivemover_p.cpp"