Struct ArchiveEntry 

pub struct ArchiveEntry {
    pub path: String,
    pub kind: ArchiveEntryKind,
    pub size: Option<u64>,
    pub mode: Option<u32>,
    pub modified_unix_seconds: Option<i64>,
}

Generic archive entry metadata.

Fields

path: String

Archive-internal path.

kind: ArchiveEntryKind

Archive entry kind.

size: Option<u64>

Entry payload size in bytes, when known.

mode: Option<u32>

Entry mode or permission bits, when known.

modified_unix_seconds: Option<i64>

Unix timestamp seconds for the modified time, when known.

Implementations

impl ArchiveEntry

pub fn new(path: impl Into<String>, kind: ArchiveEntryKind) -> ArchiveEntry

Creates archive entry metadata from a path and kind.

Examples found in repository

examples/basic_usage.rs (line 16)

fn main() {
    let encoding = ArchiveEncoding::from_extension("release.tar.zst");

    assert_eq!(encoding.archive, ArchiveFormat::Tar);
    assert_eq!(encoding.compression, CompressionFormat::Zstd);
    assert!(is_safe_relative_archive_path("docs/readme.md"));
    assert!(!is_safe_relative_archive_path("../secrets.env"));

    let policy = ArchivePolicy::strict();
    let manifest = ArchiveManifest::new(encoding).with_entries(vec![
        ArchiveEntry::new("docs/readme.md", ArchiveEntryKind::File).with_size(128),
    ]);

    assert!(policy.allows_entries(manifest.entries()));
    assert_eq!(manifest.file_count(), 1);
    assert_eq!(manifest.total_size(), 128);
}

pub fn file(path: impl Into<String>) -> ArchiveEntry

Creates a regular file entry.

pub fn directory(path: impl Into<String>) -> ArchiveEntry

Creates a directory entry.

pub fn symlink(path: impl Into<String>) -> ArchiveEntry

Creates a symbolic link entry.

pub const fn with_size(self, size: u64) -> ArchiveEntry

Adds known entry size metadata.

Examples found in repository

examples/basic_usage.rs (line 16)

fn main() {
    let encoding = ArchiveEncoding::from_extension("release.tar.zst");

    assert_eq!(encoding.archive, ArchiveFormat::Tar);
    assert_eq!(encoding.compression, CompressionFormat::Zstd);
    assert!(is_safe_relative_archive_path("docs/readme.md"));
    assert!(!is_safe_relative_archive_path("../secrets.env"));

    let policy = ArchivePolicy::strict();
    let manifest = ArchiveManifest::new(encoding).with_entries(vec![
        ArchiveEntry::new("docs/readme.md", ArchiveEntryKind::File).with_size(128),
    ]);

    assert!(policy.allows_entries(manifest.entries()));
    assert_eq!(manifest.file_count(), 1);
    assert_eq!(manifest.total_size(), 128);
}

pub const fn with_mode(self, mode: u32) -> ArchiveEntry

Adds known entry mode metadata.

pub const fn with_modified_unix_seconds(self, seconds: i64) -> ArchiveEntry

Adds known modified timestamp metadata.

pub fn path(&self) -> &str

Returns the archive-internal path.

pub const fn kind(&self) -> ArchiveEntryKind

Returns the archive entry kind.

pub const fn size(&self) -> Option<u64>

Returns the known entry size.

pub const fn mode(&self) -> Option<u32>

Returns the known entry mode.

pub const fn modified_unix_seconds(&self) -> Option<i64>

Returns the known modified timestamp.

pub const fn is_file(&self) -> bool

Returns whether this is a regular file entry.

pub const fn is_directory(&self) -> bool

Returns whether this is a directory entry.

pub const fn is_symlink(&self) -> bool

Returns whether this is a symbolic link entry.

Trait Implementations

impl Clone for ArchiveEntry

fn clone(&self) -> ArchiveEntry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ArchiveEntry

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for ArchiveEntry

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ArchiveEntry

fn eq(&self, other: &ArchiveEntry) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ArchiveEntry

impl StructuralPartialEq for ArchiveEntry