Struct ByteStream 

pub struct ByteStream { /* private fields */ }

Implementations

impl ByteStream

pub fn from_fd(fd: RawFd, automatic_close: bool) -> Result<Self>

pub fn from_file(file: File) -> Result<Self>

pub fn open_with_path( path: &str, open_flags: i32, open_mode: u32, ) -> Result<Self>

Examples found in repository

examples/05_aa_byte_stream_pipeline.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input = pseudo_random_bytes(32 * 1024);
    let artifact_dir = artifact_dir("aa-byte-stream");
    let plain_path = artifact_dir.join("payload.bin");
    let compressed_path = artifact_dir.join("payload.pbzx");
    fs::write(&plain_path, &input)?;

    let mut input_stream =
        ByteStream::open_with_path(&path_string(&plain_path), OPEN_READ_ONLY, 0)?;
    let compressed_stream = ByteStream::open_with_path(
        &path_string(&compressed_path),
        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
        DEFAULT_FILE_MODE,
    )?;
    let mut compressed_stream = compressed_stream.into_compression_output(
        ArchiveCompressionAlgorithm::Lzfse,
        64 * 1024,
        ArchiveFlags::empty(),
        0,
    )?;
    input_stream.process_into(&mut compressed_stream)?;
    compressed_stream.close()?;

    let compressed_stream =
        ByteStream::open_with_path(&path_string(&compressed_path), OPEN_READ_ONLY, 0)?;
    let mut decompressed_stream =
        compressed_stream.into_decompression_input(ArchiveFlags::empty(), 0)?;
    let output = decompressed_stream.read_to_end()?;
    assert_eq!(output, input);
    decompressed_stream.close()?;

    let compressed_len = fs::metadata(&compressed_path)?.len();
    println!("compressed bytes={compressed_len}");
    println!("✅ AppleArchive byte-stream pipeline OK");
    Ok(())
}

examples/04_aa_archive_stream_roundtrip.rs (lines 23-27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let data = b"hello from apple archive".to_vec();
    let artifact_dir = artifact_dir("aa-archive-stream");
    let archive_path = artifact_dir.join("sample.aar");
    let archive_path = path_string(&archive_path);

    let mut header = Header::new()?;
    let regular_file = u64::from(b'F');
    let data_len = u64::try_from(data.len())?;
    header.append_field_uint(FieldKey::TYP, regular_file)?;
    header.append_field_string(FieldKey::PAT, "greeting.txt")?;
    header.append_field_uint(FieldKey::SIZ, data_len)?;
    header.append_field_blob(FieldKey::DAT, data_len)?;

    let byte_stream = ByteStream::open_with_path(
        &archive_path,
        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
        DEFAULT_FILE_MODE,
    )?;
    let mut archive = ArchiveStream::encode_output(byte_stream, ArchiveFlags::empty(), 0)?;
    archive.write_header(&header)?;
    archive.write_blob(FieldKey::DAT, &data)?;
    archive.close()?;

    let byte_stream = ByteStream::open_with_path(&archive_path, OPEN_READ_ONLY, 0)?;
    let mut archive = ArchiveStream::decode_input(byte_stream, ArchiveFlags::empty(), 0)?;
    let header = archive.read_header()?.expect("archive entry");
    assert_eq!(header.path()?.as_deref(), Some("greeting.txt"));
    let blob = header.blob_with_key(FieldKey::DAT)?.expect("blob field");
    let mut decoded = vec![0_u8; usize::try_from(blob.size)?];
    archive.read_blob(FieldKey::DAT, &mut decoded)?;
    assert_eq!(decoded, data);
    assert!(archive.read_header()?.is_none());
    archive.close()?;

    println!("archive path={archive_path}");
    println!("✅ AppleArchive round-trip OK");
    Ok(())
}

pub fn temp_file() -> Result<Self>

pub fn shared_buffer_pipe(buffer_capacity: usize) -> Result<(Self, Self)>

pub fn into_compression_output( self, compression_algorithm: ArchiveCompressionAlgorithm, block_size: usize, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

Examples found in repository

examples/05_aa_byte_stream_pipeline.rs (lines 24-29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input = pseudo_random_bytes(32 * 1024);
    let artifact_dir = artifact_dir("aa-byte-stream");
    let plain_path = artifact_dir.join("payload.bin");
    let compressed_path = artifact_dir.join("payload.pbzx");
    fs::write(&plain_path, &input)?;

    let mut input_stream =
        ByteStream::open_with_path(&path_string(&plain_path), OPEN_READ_ONLY, 0)?;
    let compressed_stream = ByteStream::open_with_path(
        &path_string(&compressed_path),
        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
        DEFAULT_FILE_MODE,
    )?;
    let mut compressed_stream = compressed_stream.into_compression_output(
        ArchiveCompressionAlgorithm::Lzfse,
        64 * 1024,
        ArchiveFlags::empty(),
        0,
    )?;
    input_stream.process_into(&mut compressed_stream)?;
    compressed_stream.close()?;

    let compressed_stream =
        ByteStream::open_with_path(&path_string(&compressed_path), OPEN_READ_ONLY, 0)?;
    let mut decompressed_stream =
        compressed_stream.into_decompression_input(ArchiveFlags::empty(), 0)?;
    let output = decompressed_stream.read_to_end()?;
    assert_eq!(output, input);
    decompressed_stream.close()?;

    let compressed_len = fs::metadata(&compressed_path)?.len();
    println!("compressed bytes={compressed_len}");
    println!("✅ AppleArchive byte-stream pipeline OK");
    Ok(())
}

pub fn into_existing_compression_output( self, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

pub fn into_decompression_input( self, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

Examples found in repository

examples/05_aa_byte_stream_pipeline.rs (line 36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input = pseudo_random_bytes(32 * 1024);
    let artifact_dir = artifact_dir("aa-byte-stream");
    let plain_path = artifact_dir.join("payload.bin");
    let compressed_path = artifact_dir.join("payload.pbzx");
    fs::write(&plain_path, &input)?;

    let mut input_stream =
        ByteStream::open_with_path(&path_string(&plain_path), OPEN_READ_ONLY, 0)?;
    let compressed_stream = ByteStream::open_with_path(
        &path_string(&compressed_path),
        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
        DEFAULT_FILE_MODE,
    )?;
    let mut compressed_stream = compressed_stream.into_compression_output(
        ArchiveCompressionAlgorithm::Lzfse,
        64 * 1024,
        ArchiveFlags::empty(),
        0,
    )?;
    input_stream.process_into(&mut compressed_stream)?;
    compressed_stream.close()?;

    let compressed_stream =
        ByteStream::open_with_path(&path_string(&compressed_path), OPEN_READ_ONLY, 0)?;
    let mut decompressed_stream =
        compressed_stream.into_decompression_input(ArchiveFlags::empty(), 0)?;
    let output = decompressed_stream.read_to_end()?;
    assert_eq!(output, input);
    decompressed_stream.close()?;

    let compressed_len = fs::metadata(&compressed_path)?.len();
    println!("compressed bytes={compressed_len}");
    println!("✅ AppleArchive byte-stream pipeline OK");
    Ok(())
}

pub fn into_random_access_decompression_input( self, alloc_limit: usize, flags: ArchiveFlags, n_threads: i32, ) -> Result<Self>

pub fn write(&mut self, buffer: &[u8]) -> Result<usize>

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

pub fn pwrite(&mut self, buffer: &[u8], offset: i64) -> Result<usize>

pub fn read(&mut self, buffer: &mut [u8]) -> Result<usize>

pub fn pread(&mut self, buffer: &mut [u8], offset: i64) -> Result<usize>

pub fn seek(&mut self, offset: i64, whence: i32) -> Result<u64>

pub fn read_to_end(&mut self) -> Result<Vec<u8>>

Examples found in repository

examples/05_aa_byte_stream_pipeline.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input = pseudo_random_bytes(32 * 1024);
    let artifact_dir = artifact_dir("aa-byte-stream");
    let plain_path = artifact_dir.join("payload.bin");
    let compressed_path = artifact_dir.join("payload.pbzx");
    fs::write(&plain_path, &input)?;

    let mut input_stream =
        ByteStream::open_with_path(&path_string(&plain_path), OPEN_READ_ONLY, 0)?;
    let compressed_stream = ByteStream::open_with_path(
        &path_string(&compressed_path),
        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
        DEFAULT_FILE_MODE,
    )?;
    let mut compressed_stream = compressed_stream.into_compression_output(
        ArchiveCompressionAlgorithm::Lzfse,
        64 * 1024,
        ArchiveFlags::empty(),
        0,
    )?;
    input_stream.process_into(&mut compressed_stream)?;
    compressed_stream.close()?;

    let compressed_stream =
        ByteStream::open_with_path(&path_string(&compressed_path), OPEN_READ_ONLY, 0)?;
    let mut decompressed_stream =
        compressed_stream.into_decompression_input(ArchiveFlags::empty(), 0)?;
    let output = decompressed_stream.read_to_end()?;
    assert_eq!(output, input);
    decompressed_stream.close()?;

    let compressed_len = fs::metadata(&compressed_path)?.len();
    println!("compressed bytes={compressed_len}");
    println!("✅ AppleArchive byte-stream pipeline OK");
    Ok(())
}

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

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

Examples found in repository

examples/05_aa_byte_stream_pipeline.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input = pseudo_random_bytes(32 * 1024);
    let artifact_dir = artifact_dir("aa-byte-stream");
    let plain_path = artifact_dir.join("payload.bin");
    let compressed_path = artifact_dir.join("payload.pbzx");
    fs::write(&plain_path, &input)?;

    let mut input_stream =
        ByteStream::open_with_path(&path_string(&plain_path), OPEN_READ_ONLY, 0)?;
    let compressed_stream = ByteStream::open_with_path(
        &path_string(&compressed_path),
        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
        DEFAULT_FILE_MODE,
    )?;
    let mut compressed_stream = compressed_stream.into_compression_output(
        ArchiveCompressionAlgorithm::Lzfse,
        64 * 1024,
        ArchiveFlags::empty(),
        0,
    )?;
    input_stream.process_into(&mut compressed_stream)?;
    compressed_stream.close()?;

    let compressed_stream =
        ByteStream::open_with_path(&path_string(&compressed_path), OPEN_READ_ONLY, 0)?;
    let mut decompressed_stream =
        compressed_stream.into_decompression_input(ArchiveFlags::empty(), 0)?;
    let output = decompressed_stream.read_to_end()?;
    assert_eq!(output, input);
    decompressed_stream.close()?;

    let compressed_len = fs::metadata(&compressed_path)?.len();
    println!("compressed bytes={compressed_len}");
    println!("✅ AppleArchive byte-stream pipeline OK");
    Ok(())
}

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

Examples found in repository

examples/05_aa_byte_stream_pipeline.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input = pseudo_random_bytes(32 * 1024);
    let artifact_dir = artifact_dir("aa-byte-stream");
    let plain_path = artifact_dir.join("payload.bin");
    let compressed_path = artifact_dir.join("payload.pbzx");
    fs::write(&plain_path, &input)?;

    let mut input_stream =
        ByteStream::open_with_path(&path_string(&plain_path), OPEN_READ_ONLY, 0)?;
    let compressed_stream = ByteStream::open_with_path(
        &path_string(&compressed_path),
        OPEN_WRITE_ONLY | OPEN_CREATE | OPEN_TRUNCATE,
        DEFAULT_FILE_MODE,
    )?;
    let mut compressed_stream = compressed_stream.into_compression_output(
        ArchiveCompressionAlgorithm::Lzfse,
        64 * 1024,
        ArchiveFlags::empty(),
        0,
    )?;
    input_stream.process_into(&mut compressed_stream)?;
    compressed_stream.close()?;

    let compressed_stream =
        ByteStream::open_with_path(&path_string(&compressed_path), OPEN_READ_ONLY, 0)?;
    let mut decompressed_stream =
        compressed_stream.into_decompression_input(ArchiveFlags::empty(), 0)?;
    let output = decompressed_stream.read_to_end()?;
    assert_eq!(output, input);
    decompressed_stream.close()?;

    let compressed_len = fs::metadata(&compressed_path)?.len();
    println!("compressed bytes={compressed_len}");
    println!("✅ AppleArchive byte-stream pipeline OK");
    Ok(())
}

pub fn process_random_access_into( &mut self, output: &mut Self, max_offset: i64, block_size: usize, flags: ArchiveFlags, n_threads: i32, ) -> Result<u64>

Trait Implementations

impl Debug for ByteStream

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

Formats the value using the given formatter.

impl Drop for ByteStream

fn drop(&mut self)

Executes the destructor for this type.

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.