ExternalFiles.hpp

#pragma once
#include <Process/MediaRange.hpp>
 
#include <score/tools/ProjectFiles.hpp>
 
#include <QString>
 
#include <score_lib_process_export.h>
 
#include <functional>
#include <memory>
#include <optional>
#include <vector>
 
namespace score
{
class Command;
struct DocumentContext;
}
 
namespace Process
{
class ControlInlet;
class ProcessModel;
 
enum class FileUsage
{
  Input, 
  Output 
};
 
struct ExternalFileRef
{
  QString path;
  score::FileKind kind{score::FileKind::Unknown};
  FileUsage usage{FileUsage::Input};
  bool directory{};
  bool rewritable{true};
  QString owner;
 
  std::optional<MediaRange> usedRange;
 
  std::vector<QString> companions;
};
 
using CompanionFiles = std::function<std::vector<QString>(const QString& storedPath)>;
 
using ExternalFileMapper = std::function<QString(const ExternalFileRef&)>;
 
class SCORE_LIB_PROCESS_EXPORT ExternalFileMap
{
public:
  explicit ExternalFileMap(ExternalFileMapper mapper) noexcept;
  ~ExternalFileMap();
 
  ExternalFileMap(const ExternalFileMap&) = delete;
  ExternalFileMap& operator=(const ExternalFileMap&) = delete;
 
  QString map(ExternalFileRef ref);
 
  void control(
      Process::ControlInlet& inlet, score::FileKind kind,
      FileUsage usage = FileUsage::Input, const CompanionFiles& companions = {});
 
  void folder(Process::ControlInlet& inlet);
 
  template <typename T>
  void property(
      T& obj, const char* property, score::FileKind kind,
      FileUsage usage = FileUsage::Input);
 
  void readOnly(const QString& path, score::FileKind kind);
 
  void addCommand(score::Command* cmd);
 
  QString owner;
 
  std::vector<score::Command*> takeCommands() noexcept;
 
  bool hasCommands() const noexcept { return !m_commands.empty(); }
 
private:
  ExternalFileMapper m_mapper;
  std::vector<score::Command*> m_commands;
};
 
SCORE_LIB_PROCESS_EXPORT
void mapDocumentExternalFiles(const score::DocumentContext& ctx, ExternalFileMap& map);
 
SCORE_LIB_PROCESS_EXPORT
bool looksLikeExistingFile(
    const QString& value, const score::DocumentContext& ctx) noexcept;
}
 
#include <Process/Commands/RelocateFile.hpp>
 
namespace Process
{
template <typename T>
void ExternalFileMap::property(
    T& obj, const char* property, score::FileKind kind, FileUsage usage)
{
  const QString cur = obj.property(property).toString().trimmed();
  if(cur.isEmpty())
    return;
 
  const QString next
      = map({.path = cur,
             .kind = kind == score::FileKind::Unknown ? score::guessFileKind(cur) : kind,
             .usage = usage,
             .directory = false,
             .rewritable = true,
             .owner = owner});
  if(next.isEmpty() || next == cur)
    return;
 
  addCommand(new Process::RelocateFilePath{obj, QString::fromUtf8(property), next});
}
}