Struct tokio::io::Stdout

pub struct Stdout { /* private fields */ }

Available on crate feature io-std only.

A handle to the standard output stream of a process.

Concurrent writes to stdout must be executed with care: Only individual writes to this AsyncWrite are guaranteed to be intact. In particular you should be aware that writes using write_all are not guaranteed to occur as a single write, so multiple threads writing data with write_all may result in interleaved output.

Created by the stdout function.

Examples

use tokio::io::{self, AsyncWriteExt};

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut stdout = io::stdout();
    stdout.write_all(b"Hello world!").await?;
    Ok(())
}

The following is an example of using stdio with loop.

use tokio::io::{self, AsyncWriteExt};

#[tokio::main]
async fn main() {
    let messages = vec!["hello", " world\n"];

    // When you use `stdio` in a loop, it is recommended to create
    // a single `stdio` instance outside the loop and call a write
    // operation against that instance on each loop.
    //
    // Repeatedly creating `stdout` instances inside the loop and
    // writing to that handle could result in mangled output since
    // each write operation is handled by a different blocking thread.
    let mut stdout = io::stdout();

    for message in &messages {
        stdout.write_all(message.as_bytes()).await.unwrap();
        stdout.flush().await.unwrap();
    }
}

Trait Implementations

impl AsFd for Stdout

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl AsHandle for Stdout

Available on Windows only.

fn as_handle(&self) -> BorrowedHandle<'_>

See std::os::windows::io::AsHandle::as_handle

impl AsRawFd for Stdout

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsRawHandle for Stdout

Available on Windows only.

fn as_raw_handle(&self) -> RawHandle

See std::os::windows::io::AsRawHandle::as_raw_handle

impl AsyncWrite for Stdout

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

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

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl Debug for Stdout

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes