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::{DirEntryBuilder, FileEntryBuilder, SolidEntryBuilder, WriteOptions};

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

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

// Add a file to the solid entry
let mut file_builder = FileEntryBuilder::new("my_dir/file.txt".into())?;
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<SolidEntryBuilder, Error>

Creates a new SolidEntryBuilder with the given option.

Errors

Returns an error if initialization fails.

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

where NormalEntry<T>: Entry,

Adds an entry to the solid archive.

Errors

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

Examples

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

let mut builder = SolidEntryBuilder::new(WriteOptions::builder().build())?;
let dir_entry = DirEntryBuilder::new("example".into()).build()?;
builder.add_entry(dir_entry)?;
let mut entry_builder = FileEntryBuilder::new("example/text.txt".into())?;
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, attributes: impl Into<EntryWriteAttributes>, f: F, ) -> Result<(), Error>

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

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. If this method returns an error, the builder may contain a partial entry and must be discarded without further use.

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 write_opaque<F>( &mut self, name: EntryName, kind: DataKind, attributes: impl Into<EntryWriteAttributes>, f: F, ) -> Result<(), Error>

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

Writes an opaque entry payload to the solid entry.

The inner entry always uses STORE; compression and encryption are provided only by the outer solid stream. No validation is performed between kind and the payload. Prefer kind-specific APIs for data kinds defined by the PNA specification.

Errors

Returns an error if an I/O error occurs while writing the entry, or if the closure returns an error. If this method returns an error, the builder may contain a partial entry and must be discarded without further use.

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

where T: Into<RawChunk>,

Adds extra chunk to the solid entry.

pub fn max_chunk_size(&mut self, size: NonZero<u32>) -> &mut SolidEntryBuilder

Sets the maximum chunk size for data written to this solid entry.

The default is the maximum allowed chunk size (~4GB).

Examples

use std::num::NonZeroU32;
use libpna::{FileEntryBuilder, SolidEntryBuilder, WriteOptions};

let mut solid_builder = SolidEntryBuilder::new(WriteOptions::store())?;
solid_builder.max_chunk_size(NonZeroU32::new(1024 * 1024).unwrap()); // 1MB chunks

let file_entry = FileEntryBuilder::new("file.txt".into())?;
solid_builder.add_entry(file_entry.build()?)?;

let solid_entry = solid_builder.build()?;

pub fn max_file_chunk_size( &mut self, size: NonZero<u32>, ) -> &mut SolidEntryBuilder

Sets the maximum chunk size for entry data (FDAT) written via write_file() or write_opaque().

This is independent of max_chunk_size(), which controls the outer data chunking.

The default is the maximum allowed chunk size (~4GB).

pub fn build(self) -> Result<SolidEntry, Error>

Consumes this builder and returns the constructed 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()?;