export_plan.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/interchange/capability.hpp>
#include <pulp/interchange/census.hpp>
#include <pulp/interchange/concept.hpp>
#include <pulp/interchange/loss.hpp>
#include <pulp/runtime/result.hpp>
#include <pulp/timeline/model.hpp>
 
#include <cstdint>
#include <functional>
#include <span>
#include <string>
#include <utility>
#include <vector>
 
namespace pulp::interchange {

struct ExportArtifact {
    std::string name;
    std::vector<std::uint8_t> bytes;
};
 
struct ExportArtifacts {
    std::vector<ExportArtifact> artifacts;
};
 
enum class ExportErrorCode : std::uint8_t {
    UnacceptedLoss,
    NoWriterRegistered,
    WriterFailed,
    WriterFormatMismatch,
};
 
struct ExportError {
    ExportErrorCode code = ExportErrorCode::UnacceptedLoss;
    std::string message;
    std::vector<Concept> concepts;
};
 
struct ExportOptions {
    std::vector<Concept> accepted_losses;
};

class ExportPlan {
  public:
    Format format() const noexcept { return format_; }
    const timeline::Project& project() const noexcept { return project_; }
    const ConceptCensus& census() const noexcept { return census_; }

    std::span<const Concept> representable() const noexcept { return representable_; }
 
    const LossManifest& losses() const noexcept { return losses_; }
    bool is_lossless() const noexcept { return losses_.empty(); }

    std::vector<Concept> required_consent() const;
 
  private:
    friend ExportPlan plan_export(const timeline::Project&, Format, const CensusLimits&);
    ExportPlan(timeline::Project project, Format format)
        : format_(format), project_(std::move(project)) {}
 
    Format format_{};
    timeline::Project project_;
    ConceptCensus census_;
    std::vector<Concept> representable_;
    LossManifest losses_;
};

ExportPlan plan_export(const timeline::Project& project, Format format,
                       const CensusLimits& limits = {});

std::string loss_manifest_json(const ExportPlan& plan);

using ExportWriter =
    std::function<runtime::Result<ExportArtifacts, ExportError>(const ExportPlan&)>;

class FormatBoundExportWriter {
  public:
    using Function =
        std::function<runtime::Result<ExportArtifacts, ExportError>(const ExportPlan&)>;
 
    FormatBoundExportWriter() = default;
    FormatBoundExportWriter(Format format, Function function)
        : format_(format), function_(std::move(function)) {}
 
    explicit operator bool() const noexcept { return static_cast<bool>(function_); }
    Format format() const noexcept { return format_; }
 
  private:
    friend runtime::Result<ExportArtifacts, ExportError>
    run_export(const ExportPlan&, const ExportOptions&, const FormatBoundExportWriter&);
 
    Format format_{};
    Function function_;
};

runtime::Result<ExportArtifacts, ExportError>
run_export(const ExportPlan& plan, const ExportOptions& options, const ExportWriter& writer);

runtime::Result<ExportArtifacts, ExportError>
run_export(const ExportPlan& plan, const ExportOptions& options,
           const FormatBoundExportWriter& writer);
 
} // namespace pulp::interchange