Struct Archive 

pub struct Archive<R: Read> { /* private fields */ }

A structure for reading archives.

Implementations

impl<R: Read> Archive<R>

pub fn new(reader: R) -> Archive<R>

Create a new archive reader with the underlying reader object as the source of all data read.

Examples found in repository

examples/symbols.rs (line 26)

fn main() {
    let num_args = env::args().count();
    if num_args != 2 {
        println!("Usage: symbols <path/to/archive.a>");
        return;
    }

    let input_path = env::args().nth(1).unwrap();
    let input_path = Path::new(&input_path);
    let input_file =
        File::open(input_path).expect("failed to open input file");
    let mut archive = ar::Archive::new(input_file);

    for symbol in archive.symbols().expect("failed to parse symbols") {
        println!("{}", String::from_utf8_lossy(symbol));
    }
}

examples/extract.rs (line 34)

fn main() {
    let num_args = env::args().count();
    if num_args != 2 {
        println!("Usage: extract <path/to/archive.a>");
        return;
    }

    let input_path = env::args().nth(1).unwrap();
    let input_path = Path::new(&input_path);
    let input_file =
        File::open(input_path).expect("failed to open input file");
    let mut archive = ar::Archive::new(input_file);

    while let Some(entry) = archive.next_entry() {
        let mut entry = entry.expect("failed to parse archive entry");
        let output_path = Path::new(
            str::from_utf8(entry.header().identifier())
                .expect("Non UTF-8 filename"),
        )
        .to_path_buf();
        let mut output_file = File::create(&output_path)
            .expect(&format!("unable to create file {:?}", output_path));
        io::copy(&mut entry, &mut output_file)
            .expect(&format!("failed to extract file {:?}", output_path));
    }
}

pub fn variant(&self) -> Variant

Returns which format variant this archive appears to be so far.

Note that this may not be accurate before the archive has been fully read (i.e. before the next_entry() method returns None). In particular, a new Archive object that hasn’t yet read any data at all will always return Variant::Common.

pub fn into_inner(self) -> Result<R>

Unwrap this archive reader, returning the underlying reader object.

pub fn next_entry(&mut self) -> Option<Result<Entry<'_, R>>>

Reads the next entry from the archive, or returns None if there are no more.

Examples found in repository

examples/extract.rs (line 36)

fn main() {
    let num_args = env::args().count();
    if num_args != 2 {
        println!("Usage: extract <path/to/archive.a>");
        return;
    }

    let input_path = env::args().nth(1).unwrap();
    let input_path = Path::new(&input_path);
    let input_file =
        File::open(input_path).expect("failed to open input file");
    let mut archive = ar::Archive::new(input_file);

    while let Some(entry) = archive.next_entry() {
        let mut entry = entry.expect("failed to parse archive entry");
        let output_path = Path::new(
            str::from_utf8(entry.header().identifier())
                .expect("Non UTF-8 filename"),
        )
        .to_path_buf();
        let mut output_file = File::create(&output_path)
            .expect(&format!("unable to create file {:?}", output_path));
        io::copy(&mut entry, &mut output_file)
            .expect(&format!("failed to extract file {:?}", output_path));
    }
}

impl<R: Read + Seek> Archive<R>

pub fn count_entries(&mut self) -> Result<usize>

Scans the archive and returns the total number of entries in the archive (not counting special entries, such as the GNU archive name table or symbol table, that are not returned by next_entry()).

pub fn jump_to_entry(&mut self, index: usize) -> Result<Entry<'_, R>>

Scans the archive and jumps to the entry at the given index. Returns an error if the index is not less than the result of count_entries().

pub fn symbols(&mut self) -> Result<Symbols<'_, R>>

Scans the archive and returns an iterator over the symbols in the archive’s symbol table. If the archive doesn’t have a symbol table, this method will still succeed, but the iterator won’t produce any values.

Examples found in repository

examples/symbols.rs (line 28)

fn main() {
    let num_args = env::args().count();
    if num_args != 2 {
        println!("Usage: symbols <path/to/archive.a>");
        return;
    }

    let input_path = env::args().nth(1).unwrap();
    let input_path = Path::new(&input_path);
    let input_file =
        File::open(input_path).expect("failed to open input file");
    let mut archive = ar::Archive::new(input_file);

    for symbol in archive.symbols().expect("failed to parse symbols") {
        println!("{}", String::from_utf8_lossy(symbol));
    }
}