Struct ChmFile

pub struct ChmFile { /* private fields */ }

Implementations

impl ChmFile

pub fn open<P: AsRef<Path>>(path: P) -> Result<ChmFile, OpenError>

Open a ChmFile from the file system.

Examples found in repository

examples/extract.rs (line 17)

fn main() {
    let args: Vec<_> = env::args().skip(1).collect();
    if args.len() != 2 || args.iter().any(|arg| arg.contains("-h")) {
        println!("Usage: extract <chm-file> <out-dir>");
        return;
    }

    let mut file = ChmFile::open(&args[0]).expect("Unable to open the file");

    let out_dir = PathBuf::from(&args[1]);

    file.for_each(Filter::all(), |file, item| extract(&out_dir, file, &item))
        .unwrap();
}

examples/enumerate-items.rs (line 10)

fn main() {
    let filename = env::args()
        .nth(1)
        .unwrap_or_else(|| panic!("Usage: enumerate-items <filename>"));

    let mut file = ChmFile::open(&filename).expect("Unable to open the file");

    println!("{}:", filename);
    println!(" spc    start   length   type\t\t\tname");
    println!(" ===    =====   ======   ====\t\t\t====");

    file.for_each(Filter::all(), |_file, item| {
        describe_item(item);
        Continuation::Continue
    })
    .unwrap();
}

pub fn find<P: AsRef<Path>>(&mut self, path: P) -> Option<UnitInfo>

Find a particular object in the archive.

pub fn for_each<F, C>( &mut self, filter: Filter, cb: F, ) -> Result<(), EnumerationError>

where F: FnMut(&mut ChmFile, UnitInfo) -> C, C: Into<Continuation>,

Inspect each item within the ChmFile.

Examples found in repository

examples/extract.rs (line 21)

fn main() {
    let args: Vec<_> = env::args().skip(1).collect();
    if args.len() != 2 || args.iter().any(|arg| arg.contains("-h")) {
        println!("Usage: extract <chm-file> <out-dir>");
        return;
    }

    let mut file = ChmFile::open(&args[0]).expect("Unable to open the file");

    let out_dir = PathBuf::from(&args[1]);

    file.for_each(Filter::all(), |file, item| extract(&out_dir, file, &item))
        .unwrap();
}

examples/enumerate-items.rs (lines 16-19)

fn main() {
    let filename = env::args()
        .nth(1)
        .unwrap_or_else(|| panic!("Usage: enumerate-items <filename>"));

    let mut file = ChmFile::open(&filename).expect("Unable to open the file");

    println!("{}:", filename);
    println!(" spc    start   length   type\t\t\tname");
    println!(" ===    =====   ======   ====\t\t\t====");

    file.for_each(Filter::all(), |_file, item| {
        describe_item(item);
        Continuation::Continue
    })
    .unwrap();
}

pub fn for_each_item_in_dir<F, C, P>( &mut self, filter: Filter, prefix: P, cb: F, ) -> Result<(), EnumerationError>

where P: AsRef<Path>, F: FnMut(&mut ChmFile, UnitInfo) -> C, C: Into<Continuation>,

Inspect each item within the ChmFile inside a specified directory.

pub fn read( &mut self, unit: &UnitInfo, offset: u64, buffer: &mut [u8], ) -> Result<usize, ReadError>

Examples found in repository

examples/extract.rs (line 58)

fn extract(
    root_dir: &Path,
    file: &mut ChmFile,
    item: &UnitInfo,
) -> Result<(), Box<dyn Error>> {
    if !item.is_file() || !item.is_normal() {
        // we only care about normal files
        return Ok(());
    }
    let path = match item.path() {
        Some(p) => p,
        // if we can't get the path, ignore it and continue
        None => return Ok(()),
    };

    let mut dest = root_dir.to_path_buf();
    // Note: by design, the path for a normal file is absolute (starts with "/")
    // so when joining it with the root_dir we need to drop the initial "/".
    dest.extend(path.components().skip(1));

    // make sure the parent directory exists
    if let Some(parent) = dest.parent() {
        fs::create_dir_all(parent)?;
    }

    let mut f = File::create(dest)?;
    let mut start_offset = 0;
    // CHMLib doesn't give us a &[u8] with the file contents directly (e.g.
    // because it may be compressed) so we need to copy chunks to an
    // intermediate buffer
    let mut buffer = vec![0; 1 << 16];

    loop {
        let bytes_read = file.read(item, start_offset, &mut buffer)?;
        if bytes_read == 0 {
            // we've reached the end of the file
            break;
        } else {
            // write this chunk to the file and continue
            start_offset += bytes_read as u64;
            f.write_all(&buffer)?;
        }
    }

    Ok(())
}

Trait Implementations

impl Debug for ChmFile

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

Formats the value using the given formatter.

impl Drop for ChmFile

fn drop(&mut self)

Executes the destructor for this type.