component.hpp

Go to the documentation of this file.

#pragma once

 
#include <compare>
#include <cstdint>
#include <string>
#include <utility>
#include <vector>
 
namespace pulp::authoring_capsule {
 
enum class Canonicality : std::uint8_t {
    canonical_input,
    derived_output,
    preview,
    receipt,
};
 
enum class SourceAvailability : std::uint8_t {
    included,
    external,
    local_only,
    omitted,
};
 
enum class Editability : std::uint8_t { editable, opaque };
 
enum class Disclosure : std::uint8_t {
    public_,
    recipient_scoped,
    private_,
    redacted,
    not_recorded,
};

class Redistribution {
public:
    enum class State : std::uint8_t { unknown = 0, restricted = 1, allowed = 2 };

    constexpr Redistribution() = default;

    [[nodiscard]] static constexpr Redistribution granted() {
        return Redistribution{State::allowed};
    }
    [[nodiscard]] static constexpr Redistribution restricted() {
        return Redistribution{State::restricted};
    }
    [[nodiscard]] static constexpr Redistribution unknown() { return Redistribution{}; }
 
    [[nodiscard]] constexpr State state() const { return state_; }
    [[nodiscard]] constexpr bool is_granted() const { return state_ == State::allowed; }
    [[nodiscard]] constexpr bool is_restricted() const { return state_ == State::restricted; }
    [[nodiscard]] constexpr bool is_unknown() const { return state_ == State::unknown; }
 
    friend constexpr bool operator==(const Redistribution&, const Redistribution&) = default;
 
private:
    constexpr explicit Redistribution(State state) : state_(state) {}
 
    State state_ = State::unknown;
};

enum class RequiredFor : std::uint8_t { play, rebuild, remix, publish };
 
struct ComponentPolicy {
    Canonicality canonicality = Canonicality::canonical_input;
    SourceAvailability source_availability = SourceAvailability::included;
    Editability editability = Editability::editable;
    Disclosure disclosure = Disclosure::private_;
    Redistribution redistribution;
    std::string license_expression;
    std::string license_notice_sha256;
    std::string creator;
    std::string source_uri;
    bool attribution_required = false;
    std::vector<RequiredFor> required_for;
};

struct FileEntry {
    std::string role;
    std::string path;
    std::string sha256;
    std::uint64_t bytes = 0;
    std::string media_type;
    bool executable_data = false;
    ComponentPolicy policy;
};

struct DependencyEntry {
    std::string role;
    std::string id;
    std::string sha256;
    std::uint64_t bytes = 0;
    std::string media_type;
    std::string provider;
    bool required = true;
    ComponentPolicy policy;
};

struct ComponentRef {
    enum class Kind : std::uint8_t { file, dependency };
 
    Kind kind = Kind::file;
    std::string id;
 
    [[nodiscard]] static ComponentRef to_file(std::string path) {
        return ComponentRef{Kind::file, std::move(path)};
    }
    [[nodiscard]] static ComponentRef to_dependency(std::string id) {
        return ComponentRef{Kind::dependency, std::move(id)};
    }

    friend bool operator==(const ComponentRef&, const ComponentRef&) = default;
    friend std::strong_ordering operator<=>(const ComponentRef&, const ComponentRef&) = default;
};

enum class Completeness : std::uint8_t {
    self_contained,
    resolvable,
    partial,
    play_only,
};
 
}  // namespace pulp::authoring_capsule