Struct DataEntry

pub struct DataEntry<'a, 'c> {
    path: PathBuf,
    entry: Entry<'a, CompressionDecoder<'c>>,
}

A data file contained in the tar archive of an alpm-package file.

Wraps a PathBuf that indicates the location of the file in the tar archive and a tar Entry that provides access to the data of the entry in the tar archive.

Read is implemented to allow directly reading the contents of the tar archive entry.

Notes

Uses two lifetimes for the entry field:

• 'a for the reference to the Archive that the Entry belongs to
• 'c for the CompressionDecoder

Fields

path: PathBuf

The path of the data entry in the package archive.

entry: Entry<'a, CompressionDecoder<'c>>

The raw tar entry that contains the data of the entry.

Implementations

impl<'a, 'c> DataEntry<'a, 'c>

pub fn path(&self) -> &Path

Returns the path of the data entry in the tar archive of the package.

pub fn content(&mut self) -> Result<Vec<u8>, Error>

Returns the content of the data entry.

Errors

Returns an error if Entry::read_to_end fails.

pub fn is_dir(&self) -> bool

Checks whether the DataEntry represents a directory.

Returns true if the DataEntry represents a directory, false otherwise.

Note

This is a convenience method for comparing the EntryType of the Entry::header contained in the DataEntry with EntryType::Directory.

pub fn is_file(&self) -> bool

Checks whether the DataEntry represents a regular file.

Returns true if the DataEntry represents a regular file, false otherwise.

Note

This is a convenience method for comparing the EntryType of the Entry::header contained in the DataEntry with EntryType::Regular.

pub fn is_symlink(&self) -> bool

Checks whether the DataEntry represents a symlink.

Returns true if the DataEntry represents a symlink, false otherwise.

Note

This is a convenience method for comparing the EntryType of the Entry::header contained in the DataEntry with EntryType::Symlink.

pub fn permissions(&self) -> Result<u32, Error>

Returns the access permissions that apply for the DataEntry.

Notes

• This is a convenience method for retrieving the mode of the Entry::header contained in the DataEntry.
• It returns the mode masked with 0o7777 to ensure only the permission bits are returned.

Errors

Returns an error if retrieving the mode from the entry’s header fails.

pub fn entry(&'a self) -> &'a Entry<'a, CompressionDecoder<'c>>

Returns a reference to the underlying tar Entry.

This is useful for accessing metadata of the entry, such as its header or path.

Trait Implementations

impl Debug for DataEntry<'_, '_>

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

Formats the value using the given formatter.

impl Read for DataEntry<'_, '_>

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Reads data from the entry into the provided buffer.

Delegates to Entry::read.

Errors

Returns an error if reading from the entry fails.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.