Struct tar::Entry

pub struct Entry<'a, R: 'a> {
    // some fields omitted
}

A read-only view into an entry of an archive.

This structure is a window into a portion of a borrowed archive which can be inspected. It acts as a file handle by implementing the Reader and Seek traits. An entry cannot be rewritten once inserted into an archive.

Methods

impl<'a, R: Read> Entry<'a, R>

fn header(&self) -> &Header

Returns access to the header of this entry in the archive.

This provides access to the the metadata for this entry in the archive.

fn unpack<P: AsRef<Path>>(&mut self, dst: P) -> Result<()>

Writes this file to the specified location.

This function will write the entire contents of this file into the location specified by dst. Metadata will also be propagated to the path dst.

This function will create a file at the path dst, and it is required that the intermediate directories are created. Any existing file at the location dst will be overwritten.

Examples

use std::fs::File;
use tar::Archive;

let ar = Archive::new(File::open("foo.tar").unwrap());

for (i, file) in ar.files().unwrap().enumerate() {
    let mut file = file.unwrap();
    file.unpack(format!("file-{}", i)).unwrap();
}

Trait Implementations

impl<'a, R: Read> Read for Entry<'a, R>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chars(self) -> Chars<Self>

Unstable (io)

: the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an Iterator over chars.

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

Creates an adaptor which will chain this stream with another.

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

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

impl<'a, R: Read + Seek> Seek for Entry<'a, R>

fn seek(&mut self, how: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.