archive.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/authoring_capsule/limits.hpp>
#include <pulp/authoring_capsule/status.hpp>
#include <pulp/runtime/result.hpp>
 
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::authoring_capsule {
 
struct MemberInfo {
    std::string path;
    std::uint64_t compressed_bytes = 0;
    std::uint64_t expanded_bytes = 0;
    std::uint16_t method = 0;
};

class CapsuleArchive {
public:
    CapsuleArchive(CapsuleArchive&&) noexcept;
    CapsuleArchive& operator=(CapsuleArchive&&) noexcept;
    CapsuleArchive(const CapsuleArchive&) = delete;
    CapsuleArchive& operator=(const CapsuleArchive&) = delete;
    ~CapsuleArchive();

    std::span<const MemberInfo> members() const noexcept;

    std::span<const std::uint8_t> manifest_bytes() const noexcept;

    runtime::Result<std::vector<std::uint8_t>, CapsuleError> read(std::string_view path) const;

    std::uint64_t peak_bytes() const noexcept;
 
private:
    struct Impl;
    explicit CapsuleArchive(std::unique_ptr<Impl> impl);
    std::unique_ptr<Impl> impl_;
 
    friend runtime::Result<CapsuleArchive, CapsuleError>
    open_archive(const std::filesystem::path&, const CapsuleLimits&);
};
 
runtime::Result<CapsuleArchive, CapsuleError>
open_archive(const std::filesystem::path& path, const CapsuleLimits& limits = kCapsuleLimitsV1);

struct WriteMember {
    std::string path;
    std::vector<std::uint8_t> bytes;
};

runtime::Result<std::uint64_t, CapsuleError>
write_archive_no_replace(const std::vector<WriteMember>& members,
                         const std::filesystem::path& destination,
                         const CapsuleLimits& limits = kCapsuleLimitsV1);
 
}  // namespace pulp::authoring_capsule