Struct pem_rfc7468::Encoder

pub struct Encoder<'l, 'o> { /* private fields */ }

Buffered PEM encoder.

Stateful buffered encoder type which encodes an input PEM document according to RFC 7468’s “Strict” grammar.

Implementations

impl<'l, 'o> Encoder<'l, 'o>

pub fn new(
    type_label: &'l str,
    line_ending: LineEnding,
    out: &'o mut [u8]
) -> Result<Self>

Create a new PEM Encoder with the default options which writes output into the provided buffer.

Uses the default 64-character line wrapping.

pub fn new_wrapped(
    type_label: &'l str,
    line_width: usize,
    line_ending: LineEnding,
    out: &'o mut [u8]
) -> Result<Self>

Create a new PEM Encoder which wraps at the given line width.

Note that per RFC7468 § 2 encoding PEM with any other wrap width besides 64 is technically non-compliant:

Generators MUST wrap the base64-encoded lines so that each line consists of exactly 64 characters except for the final line, which will encode the remainder of the data (within the 64-character line boundary)

This method is provided with the intended purpose of implementing the OpenSSH private key format, which uses a non-standard wrap width of 70.

pub fn type_label(&self) -> &'l str

Get the PEM type label used for this document.

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

Encode the provided input data.

This method can be called as many times as needed with any sized input to write data encoded data into the output buffer, so long as there is sufficient space in the buffer to handle the resulting Base64 encoded data.

pub fn base64_encoder(&mut self) -> &mut Base64Encoder<'o>

Borrow the inner Base64Encoder.

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

Finish encoding PEM, writing the post-encapsulation boundary.

On success, returns the total number of bytes written to the output buffer.

Trait Implementations

impl<'l, 'o> Write for Encoder<'l, 'o>

Available on crate feature std 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

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