MissingFiles.hpp

#pragma once
#include <Process/FileOperation.hpp>
 
#include <QHash>
#include <QMultiHash>
#include <QString>
 
#include <score_lib_process_export.h>
 
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <vector>
 
class QObject;
 
namespace score
{
struct DocumentContext;
}
 
namespace Process
{
 
SCORE_LIB_PROCESS_EXPORT
FileReport scanMissingFiles(const score::DocumentContext& ctx);
 
class FileScan;
 
class SCORE_LIB_PROCESS_EXPORT FileIndex
{
public:
  void scan(const QString& folder, FileScan* progress = nullptr);
 
  std::vector<QString> candidates(const QString& missingPath, qint64 size = -1) const;
 
  int fileCount() const noexcept { return int(m_byName.size()); }
  const QString& root() const noexcept { return m_root; }
 
private:
  QString m_root;
  QMultiHash<QString, QString> m_byName;
};
 
class SCORE_LIB_PROCESS_EXPORT FileScan
{
public:
  using OnFinished = std::function<void(FileIndex, bool cancelled)>;
 
  explicit FileScan(QString folder);
 
  static std::shared_ptr<FileScan>
  start(const QString& folder, QObject* context, OnFinished onFinished);
 
  void cancel() noexcept { m_cancelled.store(true, std::memory_order_relaxed); }
  bool cancelled() const noexcept
  {
    return m_cancelled.load(std::memory_order_relaxed);
  }
 
  int filesSeen() const noexcept { return m_filesSeen.load(std::memory_order_relaxed); }
  QString currentFolder() const;
 
  const QString& root() const noexcept { return m_root; }
 
private:
  friend class FileIndex;
  void fileSeen() noexcept { m_filesSeen.fetch_add(1, std::memory_order_relaxed); }
  void setCurrentFolder(const QString& folder);
 
  QString m_root;
  mutable std::mutex m_mutex;
  QString m_currentFolder;
  std::atomic_int m_filesSeen{};
  std::atomic_bool m_cancelled{};
};
 
SCORE_LIB_PROCESS_EXPORT
FileReport relinkFiles(
    const score::DocumentContext& ctx, const QHash<QString, QString>& chosen);
}