Struct 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.

Warning

Each call to stdout() creates a new handle with its own internal state. Writes through different handles are not coordinated, so creating a new handle in a loop can cause output to appear out of order:

// WRONG: creates a new handle each iteration
for i in 0..10 {
    let mut out = io::stdout();
    out.write_all(b"data").await?;
    out.write_all(b"\n").await?;
    // out is dropped here; its last write may still be
    // running when the next iteration starts
}

To preserve order, create one handle outside the loop and reuse it:

let mut out = io::stdout();
for i in 0..10 {
    out.write_all(b"data").await?;
    out.write_all(b"\n").await?;
}

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. Read more

impl AsHandle for Stdout

Available on Windows only.

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

Available on docsrs and Unix and (crate features fs or net) only.

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

impl AsRawFd for Stdout

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor. Read more

impl AsRawHandle for Stdout

Available on Windows only.

fn as_raw_handle(&self) -> RawHandle

Available on docsrs and Unix and (crate features fs or net) only.

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. Read more

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. Read more

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. Read more

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

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

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation. Read more

impl Debug for Stdout

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

Formats the value using the given formatter. Read more

Auto Trait Implementations

impl Freeze for Stdout

impl RefUnwindSafe for Stdout

impl Send for Stdout

impl Sync for Stdout

impl Unpin for Stdout

impl UnsafeUnpin for Stdout

impl UnwindSafe for Stdout

Blanket Implementations

impl<T> Any for T
where T: 'static + ?Sized,