Struct age::armor::ArmoredWriter

pub struct ArmoredWriter<W>(/* private fields */);

Writer that optionally applies the age ASCII armor format.

Examples

use std::io::Write;

let recipient = load_recipient()?;
let plaintext = b"Hello world!";

let encrypted = {
    let encryptor = age::Encryptor::with_recipients(vec![Box::new(recipient)])
        .expect("we provided a recipient");

    let mut encrypted = vec![];
    let mut writer = encryptor.wrap_output(
        age::armor::ArmoredWriter::wrap_output(
            &mut encrypted,
            age::armor::Format::AsciiArmor,
        )?
    )?;
    writer.write_all(plaintext)?;
    writer.finish()
        .and_then(|armor| armor.finish())?;

    encrypted
};

Implementations

impl<W: Write> ArmoredWriter<W>

pub fn wrap_output(output: W, format: Format) -> Result<Self>

Available on crate feature armor only.

Wraps the given output in an ArmoredWriter that will apply the given Format.

pub fn finish(self) -> Result<W>

Available on crate feature armor only.

Writes the end marker of the age file, if armoring was enabled.

You MUST call finish when you are done writing, in order to finish the armoring process. Failing to call finish will result in a truncated file that that will fail to decrypt.

impl<W: AsyncWrite> ArmoredWriter<W>

pub fn wrap_async_output(output: W, format: Format) -> Self

Available on crate features armor and async only.

Wraps the given output in an ArmoredWriter that will apply the given Format.

Trait Implementations

impl<W: AsyncWrite> AsyncWrite for ArmoredWriter<W>

Available on crate features armor and async only.

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8] ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>] ) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<W: Write> Write for ArmoredWriter<W>

Available on crate feature armor only.

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

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

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

Flush 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, fmt: 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.

impl<'pin, W> Unpin for ArmoredWriter<W>

where __ArmoredWriter<'pin, W>: Unpin,

Available on crate feature armor only.