Struct DivansBrotliHybridCompressorWriter 

pub struct DivansBrotliHybridCompressorWriter<W: Write>(/* private fields */);

Implementations

impl<W: Write> DivansBrotliHybridCompressorWriter<W>

pub fn new(writer: W, opts: DivansCompressorOptions, buffer_size: usize) -> Self

Examples found in repository

examples/compress.rs (lines 13-34)

fn main() {
    let example_opts = divans::DivansCompressorOptions::default();
    use std::io;
    let stdout = &mut io::stdout();
    {
        use std::io::{Read, Write};
        let mut writer = divans::DivansBrotliHybridCompressorWriter::new(
            stdout,
            divans::DivansCompressorOptions{
                brotli_literal_byte_score:example_opts.brotli_literal_byte_score,
                force_literal_context_mode:example_opts.force_literal_context_mode,
                literal_adaptation:example_opts.literal_adaptation, // should we override how fast the cdfs converge for literals?
                window_size:example_opts.window_size, // log 2 of the window size
                lgblock:example_opts.lgblock, // should we override how often metablocks are created in brotli
                quality:example_opts.quality, // the quality of brotli commands
                q9_5:example_opts.q9_5,
                dynamic_context_mixing:example_opts.dynamic_context_mixing, // if we want to mix together the stride prediction and the context map
                prior_depth:example_opts.prior_depth,
                use_brotli:example_opts.use_brotli, // ignored
                use_context_map:example_opts.use_context_map, // whether we should use the brotli context map in addition to the last 8 bits of each byte as a prior
                force_stride_value: example_opts.force_stride_value, // if we should use brotli to decide on the stride
                speed_detection_quality: example_opts.speed_detection_quality,
                stride_detection_quality: example_opts.stride_detection_quality,
                prior_bitmask_detection: example_opts.prior_bitmask_detection,
                divans_ir_optimizer:example_opts.divans_ir_optimizer,
            },
            4096, // internal buffer size
        );
        let mut buf = [0u8; 4096];
        loop {
            match io::stdin().read(&mut buf[..]) {
                Err(e) => {
                    if let io::ErrorKind::Interrupted = e.kind() {
                        continue;
                    }
                    panic!(e);
                }
                Ok(size) => {
                    if size == 0 {
                        match writer.flush() {
                            Err(e) => {
                                if let io::ErrorKind::Interrupted = e.kind() {
                                    continue;
                                }
                                panic!(e)
                            }
                            Ok(_) => break,
                        }
                    }
                    match writer.write_all(&buf[..size]) {
                        Err(e) => panic!(e),
                        Ok(_) => {},
                    }
                }
            }
        }
    }
}

Trait Implementations

impl<W: Write> Write for DivansBrotliHybridCompressorWriter<W>

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

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<(), Error>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.