Struct Input 

pub struct Input { /* private fields */ }

Owns an rnp_input_t for the lifetime of this value.

Construct with Input::from_memory, Input::from_path, Input::from_stdin, or Input::from_reader (any std::io::Read). Operations consume inputs through their *_with_input constructors.

When the input is reader-backed, the underlying std::io::Error of a failed read is retrievable via Input::io_error after the enclosing operation fails — librnp itself only reports a generic RNP_ERROR_READ.

Implementations

impl Input

pub fn from_memory(bytes: &[u8]) -> Result<Self>

Wrap memory as an input. The bytes are copied on the C side, so the caller’s slice does not need to outlive the Input.

pub fn from_reader(reader: impl Read + 'static) -> Result<Self>

Stream from any std::io::Read.

The reader is read lazily by librnp while the enclosing operation runs, so nothing is buffered in memory beyond librnp’s own chunk size. The reader must not be used elsewhere while the Input exists. If a read fails, the operation fails and the original std::io::Error is available via Input::io_error.

let reader = std::io::Cursor::new(b"stream me".to_vec());
let input = Input::from_reader(reader).unwrap();
let mut output = Output::to_memory().unwrap();
output.pipe(&input).unwrap();
assert_eq!(output.into_bytes().unwrap(), b"stream me");

pub fn from_boxed_reader(reader: Box<dyn Read>) -> Result<Self>

As Input::from_reader, for an already-boxed reader.

pub fn from_path(path: &str) -> Result<Self>

Open a file at path for reading.

pub fn from_stdin() -> Result<Self>

Read from process stdin.

pub fn io_error(&self) -> Option<&Error>

The std::io::Error recorded when a reader-backed input’s read callback last failed, if any. None for non-reader-backed inputs and when no read has failed.

pub fn take_io_error(&mut self) -> Option<Error>

Take the recorded std::io::Error, leaving the slot empty. See Input::io_error.

pub fn into_reader(self) -> Option<(Box<dyn Read>, Option<Error>)>

Reclaim the reader from a reader-backed Input, destroying the C handle first (which stops any further callbacks).

Returns None if this input is not reader-backed. If the reader panicked during an operation, that panic resumes here. The second tuple element is the deferred read error, if any.

Trait Implementations

impl Drop for Input

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<'a> From<Input> for MessageSource<'a>

fn from(input: Input) -> Self

Converts to this type from the input type.