Struct SolidEntryBuilder 

pub struct SolidEntryBuilder { /* private fields */ }

A builder for creating a SolidEntry.

This builder is used to construct a solid entry, which can contain multiple files compressed together as a single unit. This is particularly effective for achieving high compression ratios with many small, similar files.

Examples

use libpna::{EntryBuilder, SolidEntryBuilder, WriteOptions};

let mut solid_builder = SolidEntryBuilder::new(WriteOptions::store())?;

// Add a directory to the solid entry
let dir_entry = EntryBuilder::new_dir("my_dir/".into()).build()?;
solid_builder.add_entry(dir_entry)?;

// Add a file to the solid entry
let mut file_builder = EntryBuilder::new_file("my_dir/file.txt".into(), WriteOptions::store())?;
file_builder.write_all(b"This is a file inside a solid entry.")?;
solid_builder.add_entry(file_builder.build()?)?;

let solid_entry = solid_builder.build()?;

Implementations

impl SolidEntryBuilder

pub fn new(option: impl WriteOption) -> Result<Self>

Creates a new SolidEntryBuilder with the given option.

Arguments

• option - The option for specifying solid entry’s the compression and encryption settings.

Returns

A new SolidEntryBuilder.

Errors

Returns an error if initialization fails.

pub fn add_entry<T>(&mut self, entry: NormalEntry<T>) -> Result<usize>

where NormalEntry<T>: Entry,

Adds an entry to the solid archive.

Arguments

• entry - The entry to add to the archive.

Errors

Returns an error if an I/O error occurs while writing a given entry.

Examples

use libpna::{EntryBuilder, SolidEntryBuilder, WriteOptions};
use std::io;
use std::io::Write;

let mut builder = SolidEntryBuilder::new(WriteOptions::builder().build())?;
let dir_entry = EntryBuilder::new_dir("example".into()).build()?;
builder.add_entry(dir_entry)?;
let mut entry_builder =
    EntryBuilder::new_file("example/text.txt".into(), WriteOptions::store())?;
entry_builder.write_all(b"content")?;
let file_entry = entry_builder.build()?;
builder.add_entry(file_entry)?;
builder.build()?;

pub fn write_file<F>( &mut self, name: EntryName, metadata: Metadata, f: F, ) -> Result<()>

where F: FnMut(&mut SolidEntryDataWriter<'_>) -> Result<()>,

Writes a regular file to the solid entry.

Errors

Returns an error if an I/O error occurs while writing the entry, or if the closure returns an error.

Examples

use libpna::{Metadata, SolidEntryBuilder, WriteOptions};
use std::io::prelude::*;

let option = WriteOptions::builder().build();
let mut builder = SolidEntryBuilder::new(option)?;
builder.write_file("bar.txt".into(), Metadata::new(), |writer| {
    writer.write_all(b"text")
})?;
builder.build()?;

pub fn add_extra_chunk<T: Into<RawChunk>>(&mut self, chunk: T)

Adds extra chunk to the solid entry.

pub fn build(self) -> Result<impl Entry + Sized>

Builds the solid entry as an Entry.

Errors

Returns an error if an I/O error occurs while building entry into buffer.

Examples

use libpna::{SolidEntryBuilder, WriteOptions};
use std::io;

let builder = SolidEntryBuilder::new(WriteOptions::builder().build())?;
let entries = builder.build()?;