Enum Fmt 

pub enum Fmt {
    Tar,
    TarGz,
    TarXz,
    TarBz,
    TarZstd,
    Zip,
    SevenZip,
}

Archive format enumeration

Represents the supported archive formats. Each variant is conditionally compiled based on the corresponding feature flag.

Variants

Tar

Plain tar archive format

TarGz

Gzip-compressed tar archive (.tar.gz, .tgz)

TarXz

XZ-compressed tar archive (.tar.xz, .txz)

TarBz

Bzip2-compressed tar archive (.tar.bz2, .tbz2)

TarZstd

Zstd-compressed tar archive (.tar.zst, .tzst, .tzstd)

Zip

ZIP archive format

SevenZip

7z archive format

Implementations

impl Fmt

pub fn decode(&self, buffer: Vec<u8>) -> Result<Vec<File>>

Decode an archive from bytes

Arguments

• buffer - The archive data as bytes

Returns

• Ok(Vec<File>) - List of files extracted from the archive
• Err(ArchiveError) - If decoding fails

Example

use easy_archive::Fmt;
let data = std::fs::read("archive.tar.gz")?;
let files = Fmt::TarGz.decode(data)?;

pub fn encode(&self, files: Vec<File>) -> Result<Vec<u8>>

Encode files into an archive

Arguments

• files - List of files to include in the archive

Returns

• Ok(Vec<u8>) - The encoded archive as bytes
• Err(ArchiveError) - If encoding fails or duplicate files are detected

Example

use easy_archive::{Fmt, File};
let files = vec![
    File {
        path: "hello.txt".to_string(),
        buffer: b"Hello, world!".to_vec(),
        ..Default::default()
    }
];
let archive = Fmt::TarGz.encode(files)?;
std::fs::write("archive.tar.gz", archive)?;

pub fn guess(name: &str) -> Option<Self>

Guess the archive format from a filename

Arguments

• name - The filename to analyze

Returns

• Some(Fmt) - The detected format
• None - If the format cannot be determined

Example

use easy_archive::Fmt;
assert_eq!(Fmt::guess("archive.tar.gz"), Some(Fmt::TarGz));
assert_eq!(Fmt::guess("file.zip"), Some(Fmt::Zip));
assert_eq!(Fmt::guess("unknown.txt"), None);

pub fn extensions(&self) -> &[&'static str]

Get the file extensions for this format

Returns

A slice of file extension strings (including the leading dot)

Example

use easy_archive::Fmt;
assert_eq!(Fmt::TarGz.extensions(), &[".tar.gz", ".tgz"]);

Trait Implementations

impl Clone for Fmt

fn clone(&self) -> Fmt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Fmt

impl Debug for Fmt

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

Formats the value using the given formatter.

impl Eq for Fmt

impl Hash for Fmt

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for Fmt

type Iterator = FmtIter

fn iter() -> FmtIter

impl PartialEq for Fmt

fn eq(&self, other: &Fmt) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Fmt