Struct reopen::Reopen

pub struct Reopen<FD> { /* fields omitted */ }

A Read/Write proxy that can reopen the underlying object.

It is constructed with a function that can open a new instance of the object. If it is signaled to reopen it (though handle), it drops the old instance and uses the function to create a new one at the next IO operation.

Error handling

The reopening is performed lazily, on the first operation done to the object. Opening a new instance can fail with an error. If this happens, the error is returned as part of the operation being performed ‒ therefore, you can get an error like File not found while performing read.

If an error happens, the operation is aborted. Next time an operation is performed, another attempt to open the object is made (which in turn can fail again).

Methods

impl<FD> Reopen<FD>

pub fn new(
    constructor: Box<Fn() -> Result<FD, Error> + Send>
) -> Result<Self, Error>

Creates a new instance.

pub fn with_handle(
    handle: Handle,
    constructor: Box<Fn() -> Result<FD, Error> + Send>
) -> Result<Self, Error>

Creates a new instance from the given handle.

This might come useful if you want to create the handle beforehand with Handle::stub (eg. in lazy_static). Note that using the same handle for multiple Reopens will not work as expected (the first one to be used resets the signal and the others don't reopen).

Examples

// Something that implements `Write`, for example.
struct Writer;

let handle = Handle::stub();
let reopen = Reopen::with_handle(handle.clone(), Box::new(|| Ok(Writer)));

handle.reopen();

pub fn handle(&self) -> Handle

Returns a handle to signal this Reopen to perform the reopening.

Trait Implementations

impl<FD: Read> Read for Reopen<FD>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

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

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chars(self) -> Chars<Self>

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

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an [Iterator] over [char]s.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl<FD: Write> Write for Reopen<FD>

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

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

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

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

Attempts to write an entire buffer into this write.

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" adaptor for this instance of Write.