Skip to main content

ArchiveStream

compression

Struct ArchiveStream 

Source 
pub struct ArchiveStream { /* private fields */ }

Implementations§

Source§

impl ArchiveStream

Source

pub fn extract_output( dir: &str, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

Source

pub fn encode_output( stream: ByteStream, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

Examples found in repository?
examples/04_aa_archive_stream_roundtrip.rs (line 28)
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let data = b"hello from apple archive".to_vec();
11    let artifact_dir = artifact_dir("aa-archive-stream");
12    let archive_path = artifact_dir.join("sample.aar");
13    let archive_path = path_string(&archive_path);
14
15    let mut header = Header::new()?;
16    let regular_file = u64::from(b'F');
17    let data_len = u64::try_from(data.len())?;
18    header.append_field_uint(FieldKey::TYP, regular_file)?;
19    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
20    header.append_field_uint(FieldKey::SIZ, data_len)?;
21    header.append_field_blob(FieldKey::DAT, data_len)?;
22
23    let byte_stream = ByteStream::open_with_path(
24        &archive_path,
25        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
26        DEFAULT_FILE_MODE,
27    )?;
28    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
29    archive.write_header(&header)?;
30    archive.write_blob(FieldKey::DAT, &data)?;
31    archive.close()?;
32
33    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
34    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
35    let header = archive.read_header()?.expect("archive entry");
36    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
37    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
38    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
39    archive.read_blob(FieldKey::DAT, &mut decoded)?;
40    assert_eq!(decoded, data);
41    assert!(archive.read_header()?.is_none());
42    archive.close()?;
43
44    println!("archive path={archive_path}");
45    println!("✅ AppleArchive round-trip OK");
46    Ok(())
47}
Source

pub fn decode_input( stream: ByteStream, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

Examples found in repository?
examples/04_aa_archive_stream_roundtrip.rs (line 34)
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let data = b"hello from apple archive".to_vec();
11    let artifact_dir = artifact_dir("aa-archive-stream");
12    let archive_path = artifact_dir.join("sample.aar");
13    let archive_path = path_string(&archive_path);
14
15    let mut header = Header::new()?;
16    let regular_file = u64::from(b'F');
17    let data_len = u64::try_from(data.len())?;
18    header.append_field_uint(FieldKey::TYP, regular_file)?;
19    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
20    header.append_field_uint(FieldKey::SIZ, data_len)?;
21    header.append_field_blob(FieldKey::DAT, data_len)?;
22
23    let byte_stream = ByteStream::open_with_path(
24        &archive_path,
25        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
26        DEFAULT_FILE_MODE,
27    )?;
28    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
29    archive.write_header(&header)?;
30    archive.write_blob(FieldKey::DAT, &data)?;
31    archive.close()?;
32
33    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
34    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
35    let header = archive.read_header()?.expect("archive entry");
36    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
37    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
38    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
39    archive.read_blob(FieldKey::DAT, &mut decoded)?;
40    assert_eq!(decoded, data);
41    assert!(archive.read_header()?.is_none());
42    archive.close()?;
43
44    println!("archive path={archive_path}");
45    println!("✅ AppleArchive round-trip OK");
46    Ok(())
47}
Source

pub fn convert_output( stream: ArchiveStream, insert_key_set: &FieldKeySet, remove_key_set: &FieldKeySet, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

Source

pub fn write_header(&mut self, header: &Header) -> Result<()>

Examples found in repository?
examples/11_aa_custom_stream_callbacks.rs (line 113)
93fn main() -> Result<(), Box<dyn std::error::Error>> {
94    let byte_state = Rc::new(RefCell::new(MemoryByteState::default()));
95    let mut stream = ByteStream::custom(SharedByteCallbacks {
96        inner: byte_state,
97    })?;
98    stream.write_all(b"hello custom stream")?;
99    stream.seek(0, 0)?;
100    let mut buffer = vec![0_u8; 19];
101    stream.read(&mut buffer)?;
102    assert_eq!(&buffer, b"hello custom stream");
103
104    let archive_state = Rc::new(RefCell::new(MemoryArchiveState::default()));
105    let mut writer = ArchiveStream::custom(SharedArchiveCallbacks {
106        inner: archive_state.clone(),
107    })?;
108    let mut header = Header::new()?;
109    header.append_field_uint(FieldKey::TYP, u64::from(b'F'))?;
110    header.append_field_string(FieldKey::PAT, "custom.txt")?;
111    header.append_field_uint(FieldKey::SIZ, buffer.len() as u64)?;
112    header.append_field_blob(FieldKey::DAT, buffer.len() as u64)?;
113    writer.write_header(&header)?;
114    writer.write_blob(FieldKey::DAT, &buffer)?;
115
116    let mut reader = ArchiveStream::custom(SharedArchiveCallbacks { inner: archive_state })?;
117    let decoded_header = reader.read_header()?.expect("header");
118    assert_eq!(decoded_header.path()?.as_deref(), Some("custom.txt"));
119    let mut decoded = vec![0_u8; buffer.len()];
120    reader.read_blob(FieldKey::DAT, &mut decoded)?;
121    assert_eq!(decoded, buffer);
122
123    println!("✅ Custom AppleArchive byte/archive stream callbacks OK");
124    Ok(())
125}
More examples
Hide additional examples
examples/04_aa_archive_stream_roundtrip.rs (line 29)
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let data = b"hello from apple archive".to_vec();
11    let artifact_dir = artifact_dir("aa-archive-stream");
12    let archive_path = artifact_dir.join("sample.aar");
13    let archive_path = path_string(&archive_path);
14
15    let mut header = Header::new()?;
16    let regular_file = u64::from(b'F');
17    let data_len = u64::try_from(data.len())?;
18    header.append_field_uint(FieldKey::TYP, regular_file)?;
19    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
20    header.append_field_uint(FieldKey::SIZ, data_len)?;
21    header.append_field_blob(FieldKey::DAT, data_len)?;
22
23    let byte_stream = ByteStream::open_with_path(
24        &archive_path,
25        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
26        DEFAULT_FILE_MODE,
27    )?;
28    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
29    archive.write_header(&header)?;
30    archive.write_blob(FieldKey::DAT, &data)?;
31    archive.close()?;
32
33    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
34    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
35    let header = archive.read_header()?.expect("archive entry");
36    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
37    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
38    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
39    archive.read_blob(FieldKey::DAT, &mut decoded)?;
40    assert_eq!(decoded, data);
41    assert!(archive.read_header()?.is_none());
42    archive.close()?;
43
44    println!("archive path={archive_path}");
45    println!("✅ AppleArchive round-trip OK");
46    Ok(())
47}
Source

pub fn write_blob(&mut self, key: FieldKey, buffer: &[u8]) -> Result<()>

Examples found in repository?
examples/11_aa_custom_stream_callbacks.rs (line 114)
93fn main() -> Result<(), Box<dyn std::error::Error>> {
94    let byte_state = Rc::new(RefCell::new(MemoryByteState::default()));
95    let mut stream = ByteStream::custom(SharedByteCallbacks {
96        inner: byte_state,
97    })?;
98    stream.write_all(b"hello custom stream")?;
99    stream.seek(0, 0)?;
100    let mut buffer = vec![0_u8; 19];
101    stream.read(&mut buffer)?;
102    assert_eq!(&buffer, b"hello custom stream");
103
104    let archive_state = Rc::new(RefCell::new(MemoryArchiveState::default()));
105    let mut writer = ArchiveStream::custom(SharedArchiveCallbacks {
106        inner: archive_state.clone(),
107    })?;
108    let mut header = Header::new()?;
109    header.append_field_uint(FieldKey::TYP, u64::from(b'F'))?;
110    header.append_field_string(FieldKey::PAT, "custom.txt")?;
111    header.append_field_uint(FieldKey::SIZ, buffer.len() as u64)?;
112    header.append_field_blob(FieldKey::DAT, buffer.len() as u64)?;
113    writer.write_header(&header)?;
114    writer.write_blob(FieldKey::DAT, &buffer)?;
115
116    let mut reader = ArchiveStream::custom(SharedArchiveCallbacks { inner: archive_state })?;
117    let decoded_header = reader.read_header()?.expect("header");
118    assert_eq!(decoded_header.path()?.as_deref(), Some("custom.txt"));
119    let mut decoded = vec![0_u8; buffer.len()];
120    reader.read_blob(FieldKey::DAT, &mut decoded)?;
121    assert_eq!(decoded, buffer);
122
123    println!("✅ Custom AppleArchive byte/archive stream callbacks OK");
124    Ok(())
125}
More examples
Hide additional examples
examples/04_aa_archive_stream_roundtrip.rs (line 30)
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let data = b"hello from apple archive".to_vec();
11    let artifact_dir = artifact_dir("aa-archive-stream");
12    let archive_path = artifact_dir.join("sample.aar");
13    let archive_path = path_string(&archive_path);
14
15    let mut header = Header::new()?;
16    let regular_file = u64::from(b'F');
17    let data_len = u64::try_from(data.len())?;
18    header.append_field_uint(FieldKey::TYP, regular_file)?;
19    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
20    header.append_field_uint(FieldKey::SIZ, data_len)?;
21    header.append_field_blob(FieldKey::DAT, data_len)?;
22
23    let byte_stream = ByteStream::open_with_path(
24        &archive_path,
25        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
26        DEFAULT_FILE_MODE,
27    )?;
28    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
29    archive.write_header(&header)?;
30    archive.write_blob(FieldKey::DAT, &data)?;
31    archive.close()?;
32
33    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
34    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
35    let header = archive.read_header()?.expect("archive entry");
36    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
37    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
38    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
39    archive.read_blob(FieldKey::DAT, &mut decoded)?;
40    assert_eq!(decoded, data);
41    assert!(archive.read_header()?.is_none());
42    archive.close()?;
43
44    println!("archive path={archive_path}");
45    println!("✅ AppleArchive round-trip OK");
46    Ok(())
47}
Source

pub fn read_header(&mut self) -> Result<Option<Header>>

Examples found in repository?
examples/11_aa_custom_stream_callbacks.rs (line 117)
93fn main() -> Result<(), Box<dyn std::error::Error>> {
94    let byte_state = Rc::new(RefCell::new(MemoryByteState::default()));
95    let mut stream = ByteStream::custom(SharedByteCallbacks {
96        inner: byte_state,
97    })?;
98    stream.write_all(b"hello custom stream")?;
99    stream.seek(0, 0)?;
100    let mut buffer = vec![0_u8; 19];
101    stream.read(&mut buffer)?;
102    assert_eq!(&buffer, b"hello custom stream");
103
104    let archive_state = Rc::new(RefCell::new(MemoryArchiveState::default()));
105    let mut writer = ArchiveStream::custom(SharedArchiveCallbacks {
106        inner: archive_state.clone(),
107    })?;
108    let mut header = Header::new()?;
109    header.append_field_uint(FieldKey::TYP, u64::from(b'F'))?;
110    header.append_field_string(FieldKey::PAT, "custom.txt")?;
111    header.append_field_uint(FieldKey::SIZ, buffer.len() as u64)?;
112    header.append_field_blob(FieldKey::DAT, buffer.len() as u64)?;
113    writer.write_header(&header)?;
114    writer.write_blob(FieldKey::DAT, &buffer)?;
115
116    let mut reader = ArchiveStream::custom(SharedArchiveCallbacks { inner: archive_state })?;
117    let decoded_header = reader.read_header()?.expect("header");
118    assert_eq!(decoded_header.path()?.as_deref(), Some("custom.txt"));
119    let mut decoded = vec![0_u8; buffer.len()];
120    reader.read_blob(FieldKey::DAT, &mut decoded)?;
121    assert_eq!(decoded, buffer);
122
123    println!("✅ Custom AppleArchive byte/archive stream callbacks OK");
124    Ok(())
125}
More examples
Hide additional examples
examples/04_aa_archive_stream_roundtrip.rs (line 35)
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let data = b"hello from apple archive".to_vec();
11    let artifact_dir = artifact_dir("aa-archive-stream");
12    let archive_path = artifact_dir.join("sample.aar");
13    let archive_path = path_string(&archive_path);
14
15    let mut header = Header::new()?;
16    let regular_file = u64::from(b'F');
17    let data_len = u64::try_from(data.len())?;
18    header.append_field_uint(FieldKey::TYP, regular_file)?;
19    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
20    header.append_field_uint(FieldKey::SIZ, data_len)?;
21    header.append_field_blob(FieldKey::DAT, data_len)?;
22
23    let byte_stream = ByteStream::open_with_path(
24        &archive_path,
25        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
26        DEFAULT_FILE_MODE,
27    )?;
28    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
29    archive.write_header(&header)?;
30    archive.write_blob(FieldKey::DAT, &data)?;
31    archive.close()?;
32
33    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
34    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
35    let header = archive.read_header()?.expect("archive entry");
36    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
37    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
38    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
39    archive.read_blob(FieldKey::DAT, &mut decoded)?;
40    assert_eq!(decoded, data);
41    assert!(archive.read_header()?.is_none());
42    archive.close()?;
43
44    println!("archive path={archive_path}");
45    println!("✅ AppleArchive round-trip OK");
46    Ok(())
47}
Source

pub fn read_header_into(&mut self, header: &mut Header) -> Result<bool>

Source

pub fn read_blob(&mut self, key: FieldKey, buffer: &mut [u8]) -> Result<()>

Examples found in repository?
examples/11_aa_custom_stream_callbacks.rs (line 120)
93fn main() -> Result<(), Box<dyn std::error::Error>> {
94    let byte_state = Rc::new(RefCell::new(MemoryByteState::default()));
95    let mut stream = ByteStream::custom(SharedByteCallbacks {
96        inner: byte_state,
97    })?;
98    stream.write_all(b"hello custom stream")?;
99    stream.seek(0, 0)?;
100    let mut buffer = vec![0_u8; 19];
101    stream.read(&mut buffer)?;
102    assert_eq!(&buffer, b"hello custom stream");
103
104    let archive_state = Rc::new(RefCell::new(MemoryArchiveState::default()));
105    let mut writer = ArchiveStream::custom(SharedArchiveCallbacks {
106        inner: archive_state.clone(),
107    })?;
108    let mut header = Header::new()?;
109    header.append_field_uint(FieldKey::TYP, u64::from(b'F'))?;
110    header.append_field_string(FieldKey::PAT, "custom.txt")?;
111    header.append_field_uint(FieldKey::SIZ, buffer.len() as u64)?;
112    header.append_field_blob(FieldKey::DAT, buffer.len() as u64)?;
113    writer.write_header(&header)?;
114    writer.write_blob(FieldKey::DAT, &buffer)?;
115
116    let mut reader = ArchiveStream::custom(SharedArchiveCallbacks { inner: archive_state })?;
117    let decoded_header = reader.read_header()?.expect("header");
118    assert_eq!(decoded_header.path()?.as_deref(), Some("custom.txt"));
119    let mut decoded = vec![0_u8; buffer.len()];
120    reader.read_blob(FieldKey::DAT, &mut decoded)?;
121    assert_eq!(decoded, buffer);
122
123    println!("✅ Custom AppleArchive byte/archive stream callbacks OK");
124    Ok(())
125}
More examples
Hide additional examples
examples/04_aa_archive_stream_roundtrip.rs (line 39)
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let data = b"hello from apple archive".to_vec();
11    let artifact_dir = artifact_dir("aa-archive-stream");
12    let archive_path = artifact_dir.join("sample.aar");
13    let archive_path = path_string(&archive_path);
14
15    let mut header = Header::new()?;
16    let regular_file = u64::from(b'F');
17    let data_len = u64::try_from(data.len())?;
18    header.append_field_uint(FieldKey::TYP, regular_file)?;
19    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
20    header.append_field_uint(FieldKey::SIZ, data_len)?;
21    header.append_field_blob(FieldKey::DAT, data_len)?;
22
23    let byte_stream = ByteStream::open_with_path(
24        &archive_path,
25        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
26        DEFAULT_FILE_MODE,
27    )?;
28    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
29    archive.write_header(&header)?;
30    archive.write_blob(FieldKey::DAT, &data)?;
31    archive.close()?;
32
33    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
34    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
35    let header = archive.read_header()?.expect("archive entry");
36    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
37    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
38    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
39    archive.read_blob(FieldKey::DAT, &mut decoded)?;
40    assert_eq!(decoded, data);
41    assert!(archive.read_header()?.is_none());
42    archive.close()?;
43
44    println!("archive path={archive_path}");
45    println!("✅ AppleArchive round-trip OK");
46    Ok(())
47}
Source

pub fn write_path_list( &mut self, path_list: &PathList, key_set: &FieldKeySet, dir: &str, flags: ArchiveFlags, n_threads: i32, ) -> Result<()>

Source

pub fn process_into( &mut self, output: &mut Self, flags: ArchiveFlags, n_threads: i32, ) -> Result<u64>

Source

pub fn cancel(&mut self) -> Result<()>

Source

pub fn close(&mut self) -> Result<()>

Examples found in repository?
examples/04_aa_archive_stream_roundtrip.rs (line 31)
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let data = b"hello from apple archive".to_vec();
11    let artifact_dir = artifact_dir("aa-archive-stream");
12    let archive_path = artifact_dir.join("sample.aar");
13    let archive_path = path_string(&archive_path);
14
15    let mut header = Header::new()?;
16    let regular_file = u64::from(b'F');
17    let data_len = u64::try_from(data.len())?;
18    header.append_field_uint(FieldKey::TYP, regular_file)?;
19    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
20    header.append_field_uint(FieldKey::SIZ, data_len)?;
21    header.append_field_blob(FieldKey::DAT, data_len)?;
22
23    let byte_stream = ByteStream::open_with_path(
24        &archive_path,
25        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
26        DEFAULT_FILE_MODE,
27    )?;
28    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
29    archive.write_header(&header)?;
30    archive.write_blob(FieldKey::DAT, &data)?;
31    archive.close()?;
32
33    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
34    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
35    let header = archive.read_header()?.expect("archive entry");
36    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
37    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
38    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
39    archive.read_blob(FieldKey::DAT, &mut decoded)?;
40    assert_eq!(decoded, data);
41    assert!(archive.read_header()?.is_none());
42    archive.close()?;
43
44    println!("archive path={archive_path}");
45    println!("✅ AppleArchive round-trip OK");
46    Ok(())
47}
Source§

impl ArchiveStream

Source

pub fn custom<T: CustomArchiveStreamCallbacks + 'static>( callbacks: T, ) -> Result<Self>

Examples found in repository?
examples/11_aa_custom_stream_callbacks.rs (lines 105-107)
93fn main() -> Result<(), Box<dyn std::error::Error>> {
94    let byte_state = Rc::new(RefCell::new(MemoryByteState::default()));
95    let mut stream = ByteStream::custom(SharedByteCallbacks {
96        inner: byte_state,
97    })?;
98    stream.write_all(b"hello custom stream")?;
99    stream.seek(0, 0)?;
100    let mut buffer = vec![0_u8; 19];
101    stream.read(&mut buffer)?;
102    assert_eq!(&buffer, b"hello custom stream");
103
104    let archive_state = Rc::new(RefCell::new(MemoryArchiveState::default()));
105    let mut writer = ArchiveStream::custom(SharedArchiveCallbacks {
106        inner: archive_state.clone(),
107    })?;
108    let mut header = Header::new()?;
109    header.append_field_uint(FieldKey::TYP, u64::from(b'F'))?;
110    header.append_field_string(FieldKey::PAT, "custom.txt")?;
111    header.append_field_uint(FieldKey::SIZ, buffer.len() as u64)?;
112    header.append_field_blob(FieldKey::DAT, buffer.len() as u64)?;
113    writer.write_header(&header)?;
114    writer.write_blob(FieldKey::DAT, &buffer)?;
115
116    let mut reader = ArchiveStream::custom(SharedArchiveCallbacks { inner: archive_state })?;
117    let decoded_header = reader.read_header()?.expect("header");
118    assert_eq!(decoded_header.path()?.as_deref(), Some("custom.txt"));
119    let mut decoded = vec![0_u8; buffer.len()];
120    reader.read_blob(FieldKey::DAT, &mut decoded)?;
121    assert_eq!(decoded, buffer);
122
123    println!("✅ Custom AppleArchive byte/archive stream callbacks OK");
124    Ok(())
125}
Source§

impl ArchiveStream

Source

pub fn extract_output_with_messages<T: EntryMessageHandler + 'static>( dir: &str, flags: ArchiveFlags, n_threads: i32, handler: T, ) -> Result<Self>

Source

pub fn encode_output_with_messages<T: EntryMessageHandler + 'static>( stream: ByteStream, flags: ArchiveFlags, n_threads: i32, handler: T, ) -> Result<Self>

Source

pub fn decode_input_with_messages<T: EntryMessageHandler + 'static>( stream: ByteStream, flags: ArchiveFlags, n_threads: i32, handler: T, ) -> Result<Self>

Source

pub fn convert_output_with_messages<T: EntryMessageHandler + 'static>( stream: ArchiveStream, insert_key_set: &FieldKeySet, remove_key_set: &FieldKeySet, flags: ArchiveFlags, n_threads: i32, handler: T, ) -> Result<Self>

Source

pub fn write_path_list_with_messages<T: EntryMessageHandler + 'static>( &mut self, path_list: &PathList, key_set: &FieldKeySet, dir: &str, flags: ArchiveFlags, n_threads: i32, handler: T, ) -> Result<()>

Source

pub fn process_into_with_messages<T: EntryMessageHandler + 'static>( &mut self, output: &mut Self, flags: ArchiveFlags, n_threads: i32, handler: T, ) -> Result<u64>

Trait Implementations§

Source§

impl Debug for ArchiveStream

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Drop for ArchiveStream

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)
Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.