Struct NormalEntry 

pub struct NormalEntry<T = Vec<u8>> { /* private fields */ }

A normal entry in a PNA archive.

Normal entries represent individual files in the archive, allowing for random access to the file data. Each entry includes a header, optional password hash, data chunks, metadata, extended attributes, and any extra chunks.

Implementations

impl<T> NormalEntry<T>

pub fn header(&self) -> &EntryHeader

Returns the header of this entry.

pub fn name(&self) -> &EntryName

Returns the name of this entry.

Warning

The returned name is not sanitized. Using it directly as a filesystem path may allow path traversal. Call EntryName::sanitize before using it as a path.

pub const fn data_kind(&self) -> DataKind

Returns the data kind of this entry.

pub const fn compression(&self) -> Compression

Returns the compression method of this entry.

pub const fn encryption(&self) -> Encryption

Returns the encryption method of this entry.

pub const fn cipher_mode(&self) -> CipherMode

Returns the cipher mode of this entry’s encryption method.

pub fn metadata(&self) -> &Metadata

Returns the metadata of this entry.

pub fn xattrs(&self) -> &[ExtendedAttribute]

Returns the extended attributes of this entry.

pub fn extra_chunks(&self) -> &[RawChunk<T>]

Returns the extra chunks of this entry.

pub fn with_metadata(self, metadata: Metadata) -> NormalEntry<T>

Applies metadata to the entry.

Examples

use libpna::{EntryBuilder, Metadata};

let mut entry = EntryBuilder::new_dir("dir_entry".into()).build()?;
entry.with_metadata(Metadata::new());

pub fn with_xattrs( self, xattrs: impl Into<Vec<ExtendedAttribute>>, ) -> NormalEntry<T>

Applies extended attributes to the entry.

Examples

use libpna::{EntryBuilder, ExtendedAttribute, XattrName, XattrValue};

let mut entry = EntryBuilder::new_dir("dir_entry".into()).build()?;
entry.with_xattrs(&[ExtendedAttribute::new(
    XattrName::try_from("key").unwrap(),
    XattrValue::try_from(b"value".as_slice()).unwrap(),
)]);

pub fn with_name(self, name: EntryName) -> NormalEntry<T>

Applies a new name to the entry, preserving all other fields.

This is useful for path transformations during archive-to-archive copying where the entry data should remain unchanged.

Examples

use libpna::EntryBuilder;

let entry = EntryBuilder::new_dir("original/path".into()).build()?;
let renamed = entry.with_name("new/path".into());
assert_eq!(renamed.header().path().as_str(), "new/path");

impl<T> NormalEntry<T>

where T: Clone,

pub fn with_extra_chunks( self, chunks: impl Into<Vec<RawChunk<T>>>, ) -> NormalEntry<T>

Applies extra chunks to the entry.

Examples

use libpna::{ChunkType, EntryBuilder, RawChunk};

let mut entry = EntryBuilder::new_dir("dir_entry".into()).build()?;
entry.with_extra_chunks(&[RawChunk::from_data(
    ChunkType::private(*b"myTy").unwrap(),
    b"some data",
)]);

impl<T> NormalEntry<T>

where T: AsRef<[u8]>,

pub fn encoded_reader(&self) -> EncodedDataReader<'_>

Returns a reader over the encoded FDAT chunk body bytes.

This reader exposes the entry data as stored in the archive, before decryption or decompression. It returns the concatenated bodies of all FDAT chunks and does not include chunk length, type, or CRC bytes.

pub fn reader( &self, option: impl ReadOption, ) -> Result<EntryDataReader<'_>, Error>

Returns the reader of this NormalEntry.

Errors

Returns an error if an I/O error occurs while reading from the reader.

Examples

use libpna::{Archive, ReadOptions};
use std::{fs, io};

let file = fs::File::open("foo.pna")?;
let mut archive = Archive::read_header(file)?;
for entry in archive.entries().skip_solid() {
    let entry = entry?;
    let mut reader = entry.reader(ReadOptions::builder().build())?;
    let name = entry.header().path();
    let mut dist_file = fs::File::create(name)?;
    io::copy(&mut reader, &mut dist_file)?;
}

Trait Implementations

impl<T> Clone for NormalEntry<T>

where T: Clone,

fn clone(&self) -> NormalEntry<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for NormalEntry<T>

where T: Debug,

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

Formats the value using the given formatter.

impl EntryFsExt for NormalEntry

fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>

Creates an entry from the given path.

The path may refer to a regular file or a directory. For files, the file contents are read and embedded into the resulting entry using default WriteOptions (equivalent to WriteOptions::builder().build()). For directories, an empty directory entry is created. Symlinks are followed (uses std::fs::metadata). If the intention is to archive a symbolic link itself, use EntryBuilder::new_symlink.

Examples

use pna::NormalEntry;
use pna::prelude::*;

NormalEntry::from_path("path/to/file")?;

Errors

Returns an error if an I/O error occurs while creating the entry.

fn from_path_with<P: AsRef<Path>>( path: P, options: WriteOptions, ) -> Result<Self>

where Self: Sized,

Creates an entry from the given path with options.

Behaves like EntryFsExt::from_path, but uses the provided WriteOptions when constructing a file entry.

Examples

use pna::prelude::*;
use pna::{NormalEntry, WriteOptions};

NormalEntry::from_path_with("path/to/file", WriteOptions::store())?;

Errors

Returns an error if an I/O error occurs while creating the entry.

fn from_path_symlink<P: AsRef<Path>>(path: P) -> Result<Self>

where Self: Sized,

Creates an entry from the given path without following symlinks.

This behaves like EntryFsExt::from_path, but uses std::fs::symlink_metadata to avoid following symbolic links. When path is a symbolic link, a symbolic-link entry is created using EntryBuilder::new_symlink, with the link target captured via std::fs::read_link. For regular files and directories, behavior is identical to EntryFsExt::from_path.

Examples

use pna::NormalEntry;
use pna::prelude::*;

NormalEntry::from_path_symlink("path/to/file")?;

Errors

Returns an error if an I/O error occurs while creating the entry.

fn from_path_symlink_with<P: AsRef<Path>>( path: P, options: WriteOptions, ) -> Result<Self>

where Self: Sized,

Creates an entry from the given path with options, without following symlinks.

Behaves like EntryFsExt::from_path_with, but uses std::fs::symlink_metadata and creates a symbolic-link entry for symlinks instead of following them.

Examples

use pna::prelude::*;
use pna::{NormalEntry, WriteOptions};

NormalEntry::from_path_symlink_with("path/to/file", WriteOptions::store())?;

Errors

Returns an error if an I/O error occurs while creating the entry.

impl<'a> From<NormalEntry<&'a [u8]>> for NormalEntry

fn from(value: NormalEntry<&'a [u8]>) -> NormalEntry

Converts to this type from the input type.

impl<'a> From<NormalEntry<&'a [u8]>> for NormalEntry<Cow<'a, [u8]>>

fn from(value: NormalEntry<&'a [u8]>) -> NormalEntry<Cow<'a, [u8]>>

Converts to this type from the input type.

impl<'a> From<NormalEntry<Cow<'a, [u8]>>> for NormalEntry

fn from(value: NormalEntry<Cow<'a, [u8]>>) -> NormalEntry

Converts to this type from the input type.

impl<T> From<NormalEntry<T>> for ReadEntry<T>

fn from(value: NormalEntry<T>) -> ReadEntry<T>

Converts to this type from the input type.

impl From<NormalEntry> for NormalEntry<Cow<'_, [u8]>>

fn from(value: NormalEntry) -> NormalEntry<Cow<'_, [u8]>>

Converts to this type from the input type.

impl<T> Hash for NormalEntry<T>

where T: Hash,

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<T> Ord for NormalEntry<T>

where T: Ord,

fn cmp(&self, other: &NormalEntry<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for NormalEntry<T>

where T: PartialEq,

fn eq(&self, other: &NormalEntry<T>) -> 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<T> PartialOrd for NormalEntry<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &NormalEntry<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> TryFrom<RawEntry<T>> for NormalEntry<T>

where RawChunk<T>: Chunk,

type Error = Error

The type returned in the event of a conversion error.

fn try_from( entry: RawEntry<T>, ) -> Result<NormalEntry<T>, <NormalEntry<T> as TryFrom<RawEntry<T>>>::Error>

Performs the conversion.

impl<T> Entry for NormalEntry<T>

where NormalEntry<T>: SealedEntryExt,

impl<T> Eq for NormalEntry<T>

where T: Eq,

impl<T> StructuralPartialEq for NormalEntry<T>