Struct WritableStream 

pub struct WritableStream<R: Runtime> { /* private fields */ }

A stream for writing to a file on Android.

Implements std::io::Write, so it can be used for writing.
As with std::fs::File, wrap it with std::io::BufWriter if buffering is needed.

After writing, call WritableStream::reflect to apply changes.

Inner

This is a wrapper around std::fs::File.
In most cases, it points to the actual target file, but it may also refer to a temporary file.
For temporary files, calling WritableStream::reflect applies the changes to the actual target.

Implementations

impl<R: Runtime> SyncWritableStream<R>

pub fn into_sync(self) -> SyncWritableStream<R>

Converts to a WritableStream for synchronous processing.

pub fn into_async(self) -> AsyncWritableStream<R>

Converts to a WritableStream for asynchronous processing.

pub fn reflect(self) -> Result<()>

WritableStream is a wrapper around std::fs::File. In most cases, it points to the actual target file, but it may also refer to a temporary file.

For actual target files, this function does nothing.

For temporary files, calling this function applies the changes to the actual target, and remove the temporary file. This may take as long as the write operation or even longer. Note that if the file is located on cloud storage or similar, the function returns without waiting for the uploading to complete.

If not called explicitly, the same process is performed asynchronously on drop, and all errors is are ignored.

pub fn sync_all(&self) -> Result<()>

WritableStream is a wrapper around std::fs::File.
In most cases, it points to the actual target file, but it may also refer to a temporary file.

For actual target files, calls std::fs::File::sync_all.
For temporary files, this function does nothing.

pub fn sync_data(&self) -> Result<()>

WritableStream is a wrapper around std::fs::File.
In most cases, it points to the actual target file, but it may also refer to a temporary file.

For actual target files, calls std::fs::File::sync_data.
For temporary files, this function does nothing.

Trait Implementations

impl<R: Runtime> Write for SyncWritableStream<R>

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

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

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

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

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

Attempts to write an entire buffer into this writer.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

Like write, except that it writes from a slice of buffers.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>

Writes a formatted string into this writer, returning any error encountered.

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_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 by_ref(&mut self) -> &mut Self

where Self: Sized,

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