[][src]Struct sequoia_openpgp::serialize::stream::Compressor

pub struct Compressor<'a> { /* fields omitted */ }

Compresses a message.

Writes a compressed data packet containing all packets written to this writer.

Methods

impl<'a> Compressor<'a>[src]

pub fn new(inner: Message<'a>) -> Self[src]

Creates a new compressor using the default algorithm and compression level.

To change the compression algorithm use Compressor::algo. Use Compressor::level to change the compression level.

Example

use std::io::Write;
use sequoia_openpgp as openpgp;
use openpgp::serialize::stream::{Message, Compressor, LiteralWriter};
use openpgp::types::CompressionAlgorithm;

let message = Message::new(&mut sink);
let message = Compressor::new(message)
    // Customize the `Compressor` here.
    .build()?;
let mut message = LiteralWriter::new(message).build()?;
message.write_all(b"Hello world.")?;
message.finalize()?;

pub fn algo(self, algo: CompressionAlgorithm) -> Self[src]

Sets the compression algorithm.

Example

use std::io::Write;
use sequoia_openpgp as openpgp;
use openpgp::serialize::stream::{Message, Compressor, LiteralWriter};
use openpgp::types::CompressionAlgorithm;

let mut sink = vec![];
{
    let message = Message::new(&mut sink);
    let message = Compressor::new(message)
        .algo(CompressionAlgorithm::Uncompressed)
        .build()?;
    let mut message = LiteralWriter::new(message).build()?;
    message.write_all(b"Hello world.")?;
    message.finalize()?;
}
assert_eq!(b"\xc8\x15\x00\xcb\x12b\x00\x00\x00\x00\x00Hello world.",
           sink.as_slice());

pub fn level(self, level: CompressionLevel) -> Self[src]

Sets the compression level.

Example

use std::io::Write;
use sequoia_openpgp as openpgp;
use openpgp::serialize::stream::{Message, Compressor, LiteralWriter};
use openpgp::types::{CompressionAlgorithm, CompressionLevel};

let message = Message::new(&mut sink);
let message = Compressor::new(message)
    .level(CompressionLevel::fastest())
    .build()?;
let mut message = LiteralWriter::new(message).build()?;
message.write_all(b"Hello world.")?;
message.finalize()?;

pub fn build(self) -> Result<Message<'a>>[src]

Builds the compressor, returning the writer stack.

The most useful filter to push to the writer stack next is the Signer or the LiteralWriter. Finally, literal data must be wrapped using the LiteralWriter.

Example

use std::io::Write;
use sequoia_openpgp as openpgp;
use openpgp::serialize::stream::{Message, Compressor, LiteralWriter};
use openpgp::types::CompressionAlgorithm;

let message = Message::new(&mut sink);
let message = Compressor::new(message)
    // Customize the `Compressor` here.
    .build()?;
let mut message = LiteralWriter::new(message).build()?;
message.write_all(b"Hello world.")?;
message.finalize()?;

Trait Implementations

impl<'a> Debug for Compressor<'a>[src]

impl<'a> Write for Compressor<'a>[src]

fn write_vectored(&mut self, bufs: &[IoVec]) -> Result<usize, Error>[src]

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

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

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

Attempts to write an entire buffer into this writer. Read more

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>
1.0.0
[src]

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

fn by_ref(&mut self) -> &mut Self
1.0.0
[src]

Creates a "by reference" adaptor for this instance of Write. Read more

Auto Trait Implementations

impl<'a> !Send for Compressor<'a>

impl<'a> !Sync for Compressor<'a>

Blanket Implementations

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

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

The type returned in the event of a conversion error.