[][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.

Implementations

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.

Examples

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.

Examples

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.

Examples

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.

Examples

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]

Auto Trait Implementations

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

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

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

impl<'a> Unpin for Compressor<'a>

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

Blanket Implementations

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

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

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

impl<T> From<T> for T[src]

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

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

The type returned in the event of a conversion error.