Struct io_streams::StreamWriter

pub struct StreamWriter { /* fields omitted */ }

An unbuffered and unlocked output byte stream, implementing Write, abstracted over the destination of the output.

It primarily consists of a single file handle, and also contains any resources needed to safely hold the file handle live.

Since it is unbuffered, and since many destinations have high per-call overhead, it is often beneficial to wrap this in a BufWriter or LineWriter.

Implementations

impl StreamWriter

pub fn stdout() -> Result<Self>

Write to standard output.

Unlike std::io::stdout, this stdout returns a stream which is unbuffered and unlocked.

Since it is unbuffered, it is often beneficial to wrap the resulting StreamWriter in a BufWriter or LineWriter.

This acquires a std::io::StdoutLock (in a non-recursive way) to prevent accesses to std::io::Stdout while this is live, and fails if a StreamWriter or StreamDuplexer for standard output already exists.

#[must_use]

pub fn file<Filelike: IntoUnsafeFile + Read + Write + Seek>(
    filelike: Filelike
) -> Self

Write to an open file, taking ownership of it.

This method can be passed a std::fs::File or similar File types.

#[must_use]

pub fn tcp_stream<Socketlike: IntoUnsafeSocket>(socketlike: Socketlike) -> Self

Write to an open TCP stream, taking ownership of it.

This method can be passed a std::net::TcpStream or similar TcpStream types.

#[must_use]

pub fn unix_stream(unix_stream: UnixStream) -> Self

Write to an open Unix-domain stream, taking ownership of it.

#[must_use]

pub fn pipe_writer(pipe_writer: PipeWriter) -> Self

Write to the writing end of an open pipe, taking ownership of it.

pub fn write_to_command(command: Command) -> Result<Self>

Spawn the given command and write to its standard input. Its standard output is redirected to Stdio::null().

#[must_use]

pub fn child_stdin(child_stdin: ChildStdin) -> Self

Write to the given child standard input, taking ownership of it.

pub fn piped_thread(boxed_write: Box<dyn Write + Send>) -> Result<Self>

Write to a boxed Write implementation, taking ownership of it. This works by creating a new thread to read the data through a pipe and write it.

Writes to the pipe aren’t synchronous with writes to the boxed Write implementation. To ensure data is flushed all the way through the thread and into the boxed Write implementation, call flush(), which synchronizes with the thread to ensure that is has completed writing all pending output.

pub fn null() -> Result<Self>

Write to the null device, which ignores all data.

Trait Implementations

impl AsRawFd for StreamWriter

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for StreamWriter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Write for StreamWriter

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>

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<()>

Attempts to write an entire buffer into this writer.

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

🔬 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<()>

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.

impl OwnsRaw for StreamWriter